xml-general-cvs mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From pbw...@apache.org
Subject cvs commit: xml-site/targets/fop/design/alt.design/properties AbstractPropertyValue.html AutoRestore.html BorderCommonStyle.html BorderCommonWidth.html BorderLeftStyle.html BorderLeftWidth.html Character.html classes-overview.html Direction.html enumerated-values.html FOAttributes.html getInitialValue.html index.html introduction.html PropertyConsts-class.html PropertyConsts.html propertyExpressions.html Property.html PropertyParser.html PropertySets.html PropertyTokenizer.html PropertyValue.html PropertyValueList.html PropNames.html RenderingIntent.html ShorthandPropSets.html simple-properties.html
Date Fri, 24 Jan 2003 10:46:50 GMT
pbwest      2003/01/24 02:46:50

  Added:       targets/fop/design/alt.design/properties
                        AbstractPropertyValue.html AutoRestore.html
                        BorderCommonStyle.html BorderCommonWidth.html
                        BorderLeftStyle.html BorderLeftWidth.html
                        Character.html classes-overview.html Direction.html
                        enumerated-values.html FOAttributes.html
                        getInitialValue.html index.html introduction.html
                        PropertyConsts-class.html PropertyConsts.html
                        propertyExpressions.html Property.html
                        PropertyParser.html PropertySets.html
                        PropertyTokenizer.html PropertyValue.html
                        PropertyValueList.html PropNames.html
                        RenderingIntent.html ShorthandPropSets.html
                        simple-properties.html
  Log:
  alt.design properties html files
  
  Revision  Changes    Path
  1.1                  xml-site/targets/fop/design/alt.design/properties/AbstractPropertyValue.html
  
  Index: AbstractPropertyValue.html
  ===================================================================
  <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN">
  <!-- Created by htmlize-0.67 in css mode. -->
  <html>
    <head>
      <title>AbstractPropertyValue.java</title>
      <style type="text/css">
      <!--
        body {
          color: #000000;
          background-color: #faf0e6;
        } /* default */
        .jde-java-font-lock-package {
          color: #0000cd;
          background-color: #faf0e6;
        } /* jde-java-font-lock-package-face */
        .jde-java-font-lock-constant {
          color: #5f9ea0;
          background-color: #faf0e6;
        } /* jde-java-font-lock-constant-face */
        .keyword {
          color: #8b0000;
          background-color: #faf0e6;
        } /* font-lock-keyword-face */
        .jde-java-font-lock-doc-tag {
          color: #008b00;
          background-color: #faf0e6;
        } /* jde-java-font-lock-doc-tag-face */
        .jde-java-font-lock-number {
          color: #bc8f8f;
          background-color: #faf0e6;
        } /* jde-java-font-lock-number-face */
        .jde-java-font-lock-italic {
          background-color: #faf0e6;
          font-style: italic;
        } /* jde-java-font-lock-italic-face */
        .string {
          color: #008b00;
          background-color: #faf0e6;
        } /* font-lock-string-face */
        .variable-name {
          color: #8b008b;
          background-color: #faf0e6;
        } /* font-lock-variable-name-face */
        .jde-java-font-lock-modifier {
          color: #da70d6;
          background-color: #faf0e6;
        } /* jde-java-font-lock-modifier-face */
        .type {
          color: #4682b4;
          background-color: #faf0e6;
        } /* font-lock-type-face */
        .comment {
          color: #00008b;
          background-color: #faf0e6;
        } /* font-lock-comment-face */
        .function-name {
          color: #8b2323;
          background-color: #faf0e6;
        } /* font-lock-function-name-face */
        a {
          color: inherit;
          background-color: inherit;
          font: inherit;
          text-decoration: inherit;
        }
        a:hover {
          text-decoration: underline;
        }
      -->
      </style>
    </head>
    <body>
      <pre>
  <span class="keyword">package</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>;
  
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="type">PropertyConsts</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="type">PropNames</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="jde-java-font-lock-package">properties</span>.<span class="jde-java-font-lock-number">*</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="type">FONode</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="jde-java-font-lock-package">expr</span>.<span class="type">PropertyException</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">PropertyValue</span>;
  
  <span class="comment">/*
   * AbstractPropertyValue.java
   * $Id: AbstractPropertyValue.html,v 1.1 2003/01/24 10:46:48 pbwest Exp $
   *
   * Copyright (C) 2001 The Apache Software Foundation. All rights reserved.
   * For details on use and redistribution please refer to the
   * LICENSE file included with these sources.
   * @author &lt;a href=&quot;mailto:pbwest@powerup.com.au&quot;&gt;Peter B. West&lt;/a&gt;
   * @version $Revision: 1.1 $ $Name:  $
   */</span>
  <span class="comment">/**
   * Base abstract class for all property value types.
   */</span>
  
  <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">abstract</span> <span class="keyword">class</span> <span class="function-name" id="AbstractPropertyValueClass">AbstractPropertyValue</span>
      <span class="keyword">implements</span> <span class="type">PropertyValue</span>, <span class="type">Cloneable</span>
  {
      
      <span class="comment">/**
       * An integer index to the type of property of which this is a value.
       */</span>
      <span class="jde-java-font-lock-modifier">protected</span> <span class="type">int</span> <span class="variable-name" id="property">property</span>;
      
      <span class="comment">/**
       * An integer property type.
       */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span> <span class="variable-name" id="type">type</span>;
  
      <span class="comment">/**
       * The PropertyConsts singleton.
       */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">PropertyConsts</span> <span class="variable-name" id="propertyConsts">propertyConsts</span>;
      
      <span class="comment">/**
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="index">index</span><span class="comment"> index of the property in the property arrays.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">type</span><span class="comment"> of this value
       */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="function-name" id="AbstractPropertyValue">AbstractPropertyValue</span>(<span class="type">int</span> <span class="variable-name">index</span>, <span class="type">int</span> <span class="variable-name">type</span>)
          <span class="keyword">throws</span> <span class="type">PropertyException</span>
       {
          <span class="keyword">if</span> (index &lt; <span class="jde-java-font-lock-number">1</span> || index &gt; PropNames.<span class="jde-java-font-lock-constant" id="LAST_PROPERTY_INDEX">LAST_PROPERTY_INDEX</span>)
              <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(&quot;<span class="string">Invalid property index: </span>&quot; + index);
          <span class="keyword">if</span> (type &lt; <span class="jde-java-font-lock-number">0</span> || type &gt; PropertyValue.<span class="jde-java-font-lock-constant" id="LAST_PROPERTY_TYPE">LAST_PROPERTY_TYPE</span>)
              <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(&quot;<span class="string">Invalid property type: </span>&quot; + type);
          property = index;
          <span class="keyword">this</span>.type = type;
          propertyConsts = PropertyConsts.getPropertyConsts();
      }
  
      <span class="comment">/**
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="propertyName">propertyName</span><span class="comment"> a &lt;tt&gt;String&lt;/tt&gt; containing the property name.
       */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="function-name">AbstractPropertyValue</span>(<span class="type">String</span> <span class="variable-name">propertyName</span>, <span class="type">int</span> <span class="variable-name">type</span>)
          <span class="keyword">throws</span> <span class="type">PropertyException</span>
      {
          propertyConsts = PropertyConsts.getPropertyConsts();
          property = PropNames.getPropertyIndex(propertyName);
          <span class="keyword">if</span> (property &lt; <span class="jde-java-font-lock-number">1</span> || property &gt; PropNames.<span class="jde-java-font-lock-constant">LAST_PROPERTY_INDEX</span>)
              <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(&quot;<span class="string">Invalid property index: </span>&quot; + property);
          <span class="keyword">if</span> (type &lt; <span class="jde-java-font-lock-number">0</span> || type &gt; PropertyValue.<span class="jde-java-font-lock-constant">LAST_PROPERTY_TYPE</span>)
              <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(&quot;<span class="string">Invalid property type: </span>&quot; + type);
          <span class="keyword">this</span>.type = type;
      }
  
      <span class="comment">/**
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> &lt;tt&gt;int&lt;/tt&gt; property index.
       */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">int</span> <span class="function-name" id="getProperty">getProperty</span>() {
          <span class="keyword">return</span> property;
      }
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">void</span> <span class="function-name" id="setProperty">setProperty</span>(<span class="type">int</span> <span class="variable-name">index</span>) <span class="keyword">throws</span> <span class="type">PropertyException</span> {
          <span class="keyword">if</span> (index &lt; <span class="jde-java-font-lock-number">0</span> || index &gt; PropNames.<span class="jde-java-font-lock-constant">LAST_PROPERTY_INDEX</span>)
              <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(&quot;<span class="string">Invalid property index: </span>&quot; + index);
          property = index;
      }
  
      <span class="comment">/**
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> type field of the &lt;tt&gt;PropertyValue&lt;/tt&gt;.
       */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">int</span> <span class="function-name" id="getType">getType</span>() {
          <span class="keyword">return</span> type;
      }
  
      <span class="comment">/**
       * In some circumstances, the property against which a type is to be
       * validated may not be the same as the property against which this
       * &lt;i&gt;</span><span class="jde-java-font-lock-italic">AbstractPropertyValue</span><span class="comment">&lt;/i&gt; is defined.
       * A specific property argument is then required.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="testProperty">testProperty</span><span class="comment"> &lt;tt&gt;int&lt;/tt&gt; property index of the property
       * for which the type is to be validated.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">type</span><span class="comment"> &lt;tt&gt;int&lt;/tt&gt; bitmap of data types to check for
       * validity against this property.
       */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">void</span> <span class="function-name" id="validate">validate</span>(<span class="type">int</span> <span class="variable-name">testProperty</span>, <span class="type">int</span> <span class="variable-name">type</span>)
          <span class="keyword">throws</span> <span class="type">PropertyException</span>
      {
          <span class="comment">// N.B. PROPERTY_SPECIFIC inheritance may require more specialized
  </span>        <span class="comment">// checks.  Only line-height comes into this category.
  </span>
          <span class="comment">// N.B. The first commented-out condition means that I cannot validate
  </span>        <span class="comment">// unless the property is NOT inherited.
  </span>        <span class="comment">// I can't remember why I put this
  </span>        <span class="comment">// condition in here.  Removing it.  pbw 2002/02/18
  </span>        <span class="comment">//if (propertyConsts.inherited.get(testProperty) == Property.NO
  </span>        <span class="comment">//&amp;&amp; (propertyConsts.getDataTypes(testProperty) &amp; type) == 0) {
  </span>
              <span class="keyword">if</span> ((propertyConsts.getDataTypes(testProperty) &amp; type) == <span class="jde-java-font-lock-number">0</span>) {
              <span class="type">String</span> <span class="variable-name" id="pname">pname</span> = PropNames.getPropertyName(testProperty);
              <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>
                      (&quot;<span class="string">Datatype(s) </span>&quot; +
                       Property.listDataTypes(type) +
                       &quot;<span class="string"> not defined on </span>&quot; + pname);
          }
      }
  
      <span class="comment">/**
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">type</span><span class="comment"> &lt;tt&gt;int&lt;/tt&gt; bitmap of data types to check for
       * validity against this property.
       */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">void</span> <span class="function-name">validate</span>(<span class="type">int</span> <span class="variable-name">type</span>) <span class="keyword">throws</span> <span class="type">PropertyException</span> {
          <span class="comment">// N.B. PROPERTY_SPECIFIC inheritance may require more specialized
  </span>        <span class="comment">// checks.  Only line-height comes into this category.
  </span>        validate(property, type);
      }
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="type">String</span> <span class="function-name" id="typeString">typeString</span>(<span class="type">int</span> <span class="variable-name">type</span>) {
          <span class="keyword">if</span> (type &lt; <span class="jde-java-font-lock-number">0</span> || type &gt;PropertyValue.<span class="jde-java-font-lock-constant">LAST_PROPERTY_TYPE</span>)
              <span class="keyword">return</span> &quot;<span class="string">Property type out of range</span>&quot;;
          <span class="keyword">return</span> PropertyValue.propertyTypes.get(type);
      }
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">String</span> <span class="function-name" id="toString">toString</span>() {
          <span class="keyword">try</span> {
              <span class="keyword">return</span> &quot;<span class="string">Property: </span>&quot; + PropNames.getPropertyName(property)
                      + &quot;<span class="string"> Index: </span>&quot; + property + &quot;<span class="string"> Type: </span>&quot; +
                      typeString(type);
          } <span class="keyword">catch</span> (<span class="type">PropertyException</span> <span class="variable-name" id="e">e</span>) {
              <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">RuntimeException</span>(e.getMessage());
          }
      }
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">Object</span> <span class="function-name" id="clone">clone</span>() <span class="keyword">throws</span> <span class="type">CloneNotSupportedException</span> {
          <span class="keyword">return</span> <span class="keyword">super</span>.clone();
      }
  }
  </pre>
    </body>
  </html>
  
  
  
  1.1                  xml-site/targets/fop/design/alt.design/properties/AutoRestore.html
  
  Index: AutoRestore.html
  ===================================================================
  <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN">
  <!-- Created by htmlize-0.67 in css mode. -->
  <html>
    <head>
      <title>AutoRestore.java</title>
      <style type="text/css">
      <!--
        body {
          color: #000000;
          background-color: #faf0e6;
        } /* default */
        .variable-name {
          color: #8b008b;
          background-color: #faf0e6;
        } /* font-lock-variable-name-face */
        .jde-java-font-lock-package {
          color: #0000cd;
          background-color: #faf0e6;
        } /* jde-java-font-lock-package-face */
        .jde-java-font-lock-constant {
          color: #5f9ea0;
          background-color: #faf0e6;
        } /* jde-java-font-lock-constant-face */
        .keyword {
          color: #8b0000;
          background-color: #faf0e6;
        } /* font-lock-keyword-face */
        .type {
          color: #4682b4;
          background-color: #faf0e6;
        } /* font-lock-type-face */
        .jde-java-font-lock-modifier {
          color: #da70d6;
          background-color: #faf0e6;
        } /* jde-java-font-lock-modifier-face */
        .function-name {
          color: #8b2323;
          background-color: #faf0e6;
        } /* font-lock-function-name-face */
        a {
          color: inherit;
          background-color: inherit;
          font: inherit;
          text-decoration: inherit;
        }
        a:hover {
          text-decoration: underline;
        }
      -->
      </style>
    </head>
    <body>
      <pre>
  <span class="keyword">package</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="jde-java-font-lock-package">properties</span>;
  
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="jde-java-font-lock-package">properties</span>.<span class="type">Property</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="type">PropNames</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="jde-java-font-lock-package">expr</span>.<span class="type">PropertyException</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">PropertyValue</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">Bool</span>;
  
  <span class="jde-java-font-lock-modifier">public</span> <span class="keyword">class</span> <span class="function-name" id="AutoRestoreClass">AutoRestore</span> <span class="keyword">extends</span> <span class="type">Property</span>  {
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span> <span class="variable-name" id="dataTypes">dataTypes</span> = <span class="jde-java-font-lock-constant" id="BOOL">BOOL</span>;
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span> <span class="variable-name" id="traitMapping">traitMapping</span> = <span class="jde-java-font-lock-constant" id="ACTION">ACTION</span>;
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span> <span class="variable-name" id="initialValueType">initialValueType</span> = <span class="jde-java-font-lock-constant" id="BOOL_IT">BOOL_IT</span>;
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">PropertyValue</span> <span class="function-name" id="getInitialValue">getInitialValue</span>(<span class="type">int</span> <span class="variable-name" id="property">property</span>)
  	<span class="keyword">throws</span> <span class="type">PropertyException</span>
      {
  	<span class="keyword">return</span> <span class="keyword">new</span> <span class="type">Bool</span>(PropNames.<span class="jde-java-font-lock-constant" id="AUTO_RESTORE">AUTO_RESTORE</span>, <span class="jde-java-font-lock-constant">true</span>);
      }
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span> <span class="variable-name" id="inherited">inherited</span> = <span class="jde-java-font-lock-constant" id="COMPUTED">COMPUTED</span>;
  }
  
  </pre>
    </body>
  </html>
  
  
  
  1.1                  xml-site/targets/fop/design/alt.design/properties/BorderCommonStyle.html
  
  Index: BorderCommonStyle.html
  ===================================================================
  <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN">
  <!-- Created by htmlize-0.67 in css mode. -->
  <html>
    <head>
      <title>BorderCommonStyle.java</title>
      <style type="text/css">
      <!--
        body {
          color: #000000;
          background-color: #faf0e6;
        } /* default */
        .variable-name {
          color: #8b008b;
          background-color: #faf0e6;
        } /* font-lock-variable-name-face */
        .jde-java-font-lock-package {
          color: #0000cd;
          background-color: #faf0e6;
        } /* jde-java-font-lock-package-face */
        .jde-java-font-lock-constant {
          color: #5f9ea0;
          background-color: #faf0e6;
        } /* jde-java-font-lock-constant-face */
        .keyword {
          color: #8b0000;
          background-color: #faf0e6;
        } /* font-lock-keyword-face */
        .string {
          color: #008b00;
          background-color: #faf0e6;
        } /* font-lock-string-face */
        .jde-java-font-lock-number {
          color: #bc8f8f;
          background-color: #faf0e6;
        } /* jde-java-font-lock-number-face */
        .type {
          color: #4682b4;
          background-color: #faf0e6;
        } /* font-lock-type-face */
        .jde-java-font-lock-modifier {
          color: #da70d6;
          background-color: #faf0e6;
        } /* jde-java-font-lock-modifier-face */
        .comment {
          color: #00008b;
          background-color: #faf0e6;
        } /* font-lock-comment-face */
        .function-name {
          color: #8b2323;
          background-color: #faf0e6;
        } /* font-lock-function-name-face */
        a {
          color: inherit;
          background-color: inherit;
          font: inherit;
          text-decoration: inherit;
        }
        a:hover {
          text-decoration: underline;
        }
      -->
      </style>
    </head>
    <body>
      <pre>
  <span class="keyword">package</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="jde-java-font-lock-package">properties</span>;
  
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="jde-java-font-lock-package">expr</span>.<span class="type">PropertyException</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="jde-java-font-lock-package">properties</span>.<span class="type">Property</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">Ints</span>;
  
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">java</span>.<span class="jde-java-font-lock-package">util</span>.<span class="type">HashMap</span>;
  
  <span class="comment">/**
   * Pseudo-property class for common border style values occurring in a
   * number of classes.
   */</span>
  <span class="jde-java-font-lock-modifier">public</span> <span class="keyword">class</span> <span class="function-name" id="BorderCommonStyleClass">BorderCommonStyle</span> <span class="keyword">extends</span> <span class="type">Property</span>  {
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span> <span class="variable-name" id="HIDDEN">HIDDEN</span> = <span class="jde-java-font-lock-number">1</span>;
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span> <span class="variable-name" id="DOTTED">DOTTED</span> = <span class="jde-java-font-lock-number">2</span>;
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span> <span class="variable-name" id="DASHED">DASHED</span> = <span class="jde-java-font-lock-number">3</span>;
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span> <span class="variable-name" id="SOLID">SOLID</span> = <span class="jde-java-font-lock-number">4</span>;
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span> <span class="variable-name" id="DOUBLE">DOUBLE</span> = <span class="jde-java-font-lock-number">5</span>;
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span> <span class="variable-name" id="GROOVE">GROOVE</span> = <span class="jde-java-font-lock-number">6</span>;
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span> <span class="variable-name" id="RIDGE">RIDGE</span> = <span class="jde-java-font-lock-number">7</span>;
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span> <span class="variable-name" id="INSET">INSET</span> = <span class="jde-java-font-lock-number">8</span>;
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span> <span class="variable-name" id="OUTSET">OUTSET</span> = <span class="jde-java-font-lock-number">9</span>;
  
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">String</span>[] <span class="variable-name" id="rwEnums">rwEnums</span> = {
  	<span class="jde-java-font-lock-constant" id="null">null</span>
  	,&quot;<span class="string">hidden</span>&quot;
  	,&quot;<span class="string">dotted</span>&quot;
  	,&quot;<span class="string">dashed</span>&quot;
  	,&quot;<span class="string">solid</span>&quot;
  	,&quot;<span class="string">double</span>&quot;
  	,&quot;<span class="string">groove</span>&quot;
  	,&quot;<span class="string">ridge</span>&quot;
  	,&quot;<span class="string">inset</span>&quot;
  	,&quot;<span class="string">outset</span>&quot;
      };
  
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">HashMap</span> <span class="variable-name" id="rwEnumHash">rwEnumHash</span>;
      <span class="jde-java-font-lock-modifier">static</span> {
  	rwEnumHash = <span class="keyword">new</span> <span class="type">HashMap</span>(rwEnums.length);
  	<span class="keyword">for</span> (<span class="type">int</span> <span class="variable-name" id="i">i</span> = <span class="jde-java-font-lock-number">1</span>; i &lt; rwEnums.length; i++ ) {
  	    rwEnumHash.put((<span class="type">Object</span>)rwEnums[i],
  				(<span class="type">Object</span>) Ints.consts.get(i));
  	}
      }
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">int</span> <span class="function-name" id="getEnumIndex">getEnumIndex</span>(<span class="type">String</span> <span class="variable-name" id="enum">enum</span>)
          <span class="keyword">throws</span> <span class="type">PropertyException</span>
      {
          <span class="type">Integer</span> <span class="variable-name" id="ii">ii</span> = (<span class="type">Integer</span>)(rwEnumHash.get(enum));
          <span class="keyword">if</span> (ii == <span class="jde-java-font-lock-constant">null</span>)
              <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(&quot;<span class="string">Unknown enum value: </span>&quot; + enum);
          <span class="keyword">return</span> ii.intValue();
      }
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">String</span> <span class="function-name" id="getEnumText">getEnumText</span>(<span class="type">int</span> <span class="variable-name" id="index">index</span>)
          <span class="keyword">throws</span> <span class="type">PropertyException</span>
      {
          <span class="keyword">if</span> (index &lt; <span class="jde-java-font-lock-number">1</span> || index &gt;= rwEnums.length)
              <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(&quot;<span class="string">index out of range: </span>&quot; + index);
          <span class="keyword">return</span> rwEnums[index];
      }
  
  }
  
  </pre>
    </body>
  </html>
  
  
  
  1.1                  xml-site/targets/fop/design/alt.design/properties/BorderCommonWidth.html
  
  Index: BorderCommonWidth.html
  ===================================================================
  <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN">
  <!-- Created by htmlize-0.67 in css mode. -->
  <html>
    <head>
      <title>BorderCommonWidth.java</title>
      <style type="text/css">
      <!--
        body {
          color: #000000;
          background-color: #faf0e6;
        } /* default */
        .variable-name {
          color: #8b008b;
          background-color: #faf0e6;
        } /* font-lock-variable-name-face */
        .jde-java-font-lock-package {
          color: #0000cd;
          background-color: #faf0e6;
        } /* jde-java-font-lock-package-face */
        .jde-java-font-lock-constant {
          color: #5f9ea0;
          background-color: #faf0e6;
        } /* jde-java-font-lock-constant-face */
        .keyword {
          color: #8b0000;
          background-color: #faf0e6;
        } /* font-lock-keyword-face */
        .jde-java-font-lock-doc-tag {
          color: #008b00;
          background-color: #faf0e6;
        } /* jde-java-font-lock-doc-tag-face */
        .string {
          color: #008b00;
          background-color: #faf0e6;
        } /* font-lock-string-face */
        .jde-java-font-lock-number {
          color: #bc8f8f;
          background-color: #faf0e6;
        } /* jde-java-font-lock-number-face */
        .type {
          color: #4682b4;
          background-color: #faf0e6;
        } /* font-lock-type-face */
        .jde-java-font-lock-modifier {
          color: #da70d6;
          background-color: #faf0e6;
        } /* jde-java-font-lock-modifier-face */
        .comment {
          color: #00008b;
          background-color: #faf0e6;
        } /* font-lock-comment-face */
        .function-name {
          color: #8b2323;
          background-color: #faf0e6;
        } /* font-lock-function-name-face */
        a {
          color: inherit;
          background-color: inherit;
          font: inherit;
          text-decoration: inherit;
        }
        a:hover {
          text-decoration: underline;
        }
      -->
      </style>
    </head>
    <body>
      <pre>
  <span class="keyword">package</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="jde-java-font-lock-package">properties</span>;
  
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="jde-java-font-lock-package">properties</span>.<span class="type">Property</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">Length</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">Numeric</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="type">FONode</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="jde-java-font-lock-package">expr</span>.<span class="type">PropertyException</span>;
  
  <span class="comment">/**
   * Pseudo-property class for common border width values occurring in a
   * number of classes.
   */</span>
  <span class="jde-java-font-lock-modifier">public</span> <span class="keyword">class</span> <span class="function-name" id="BorderCommonWidthClass">BorderCommonWidth</span> <span class="keyword">extends</span> <span class="type">Property</span>  {
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span> <span class="variable-name" id="THIN">THIN</span> = <span class="jde-java-font-lock-number">1</span>;
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span> <span class="variable-name" id="MEDIUM">MEDIUM</span> = <span class="jde-java-font-lock-number">2</span>;
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span> <span class="variable-name" id="THICK">THICK</span> = <span class="jde-java-font-lock-number">3</span>;
  
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">String</span>[] <span class="variable-name" id="rwEnums">rwEnums</span> = {
  	<span class="jde-java-font-lock-constant" id="null">null</span>
  	,&quot;<span class="string">thin</span>&quot;
  	,&quot;<span class="string">medium</span>&quot;
  	,&quot;<span class="string">thick</span>&quot;
      };
  
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">double</span>[] <span class="variable-name" id="mappedPoints">mappedPoints</span> = {
  	<span class="jde-java-font-lock-number">0d</span>
  	,<span class="jde-java-font-lock-number">0.5d</span>
  	,<span class="jde-java-font-lock-number">1d</span>
  	,<span class="jde-java-font-lock-number">2d</span>
      };
      
      <span class="comment">// N.B. If these values change, all initial values expressed in these
  </span>    <span class="comment">// terms must be manually changed.
  </span>
      <span class="comment">/**
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> &lt;tt&gt;int&lt;/tt&gt; property index
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> &lt;tt&gt;int&lt;/tt&gt; mappedEnum enumeration value
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> &lt;tt&gt;Numeric[]&lt;/tt&gt; containing the values corresponding
       * to the MappedNumeric enumeration constants for border width
       */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">Numeric</span> <span class="function-name" id="getMappedLength">getMappedLength</span>(<span class="type">FONode</span> <span class="variable-name" id="node">node</span>, <span class="type">int</span> <span class="variable-name">property</span>, <span class="type">int</span> <span class="variable-name">enum</span>)
  	<span class="keyword">throws</span> <span class="type">PropertyException</span>
      {
  	<span class="keyword">return</span> 
  	    Length.makeLength(property, mappedPoints[enum], Length.<span class="jde-java-font-lock-constant" id="PT">PT</span>);
      }
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">int</span> <span class="function-name" id="getEnumIndex">getEnumIndex</span>(<span class="type">String</span> <span class="variable-name" id="enum">enum</span>) <span class="keyword">throws</span> <span class="type">PropertyException</span> {
          <span class="keyword">return</span> enumValueToIndex(enum, rwEnums);
      }
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">String</span> <span class="function-name" id="getEnumText">getEnumText</span>(<span class="type">int</span> <span class="variable-name" id="index">index</span>) {
          <span class="keyword">return</span> rwEnums[index];
      }
  
  }
  
  </pre>
    </body>
  </html>
  
  
  
  1.1                  xml-site/targets/fop/design/alt.design/properties/BorderLeftStyle.html
  
  Index: BorderLeftStyle.html
  ===================================================================
  <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN">
  <!-- Created by htmlize-0.67 in css mode. -->
  <html>
    <head>
      <title>BorderLeftStyle.java</title>
      <style type="text/css">
      <!--
        body {
          color: #000000;
          background-color: #faf0e6;
        } /* default */
        .variable-name {
          color: #8b008b;
          background-color: #faf0e6;
        } /* font-lock-variable-name-face */
        .jde-java-font-lock-package {
          color: #0000cd;
          background-color: #faf0e6;
        } /* jde-java-font-lock-package-face */
        .jde-java-font-lock-constant {
          color: #5f9ea0;
          background-color: #faf0e6;
        } /* jde-java-font-lock-constant-face */
        .keyword {
          color: #8b0000;
          background-color: #faf0e6;
        } /* font-lock-keyword-face */
        .type {
          color: #4682b4;
          background-color: #faf0e6;
        } /* font-lock-type-face */
        .jde-java-font-lock-modifier {
          color: #da70d6;
          background-color: #faf0e6;
        } /* jde-java-font-lock-modifier-face */
        .function-name {
          color: #8b2323;
          background-color: #faf0e6;
        } /* font-lock-function-name-face */
        a {
          color: inherit;
          background-color: inherit;
          font: inherit;
          text-decoration: inherit;
        }
        a:hover {
          text-decoration: underline;
        }
      -->
      </style>
    </head>
    <body>
      <pre>
  <span class="keyword">package</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="jde-java-font-lock-package">properties</span>;
  
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="jde-java-font-lock-package">properties</span>.<span class="type">BorderCommonStyle</span>;
  
  <span class="jde-java-font-lock-modifier">public</span> <span class="keyword">class</span> <span class="function-name" id="BorderLeftStyleClass">BorderLeftStyle</span> <span class="keyword">extends</span> <span class="type">BorderCommonStyle</span> {
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span> <span class="variable-name" id="dataTypes">dataTypes</span> = <span class="jde-java-font-lock-constant" id="ENUM">ENUM</span> | <span class="jde-java-font-lock-constant">NONE</span> | <span class="jde-java-font-lock-constant">INHERIT</span>;
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span> <span class="variable-name" id="traitMapping">traitMapping</span> = <span class="jde-java-font-lock-constant" id="DISAPPEARS">DISAPPEARS</span>;
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span> <span class="variable-name" id="initialValueType">initialValueType</span> = <span class="jde-java-font-lock-constant" id="NONE_IT">NONE_IT</span>;
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span> <span class="variable-name" id="inherited">inherited</span> = <span class="jde-java-font-lock-constant" id="NO">NO</span>;
  
  
  }
  
  </pre>
    </body>
  </html>
  
  
  
  1.1                  xml-site/targets/fop/design/alt.design/properties/BorderLeftWidth.html
  
  Index: BorderLeftWidth.html
  ===================================================================
  <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN">
  <!-- Created by htmlize-0.67 in css mode. -->
  <html>
    <head>
      <title>BorderLeftWidth.java</title>
      <style type="text/css">
      <!--
        body {
          color: #000000;
          background-color: #faf0e6;
        } /* default */
        .variable-name {
          color: #8b008b;
          background-color: #faf0e6;
        } /* font-lock-variable-name-face */
        .jde-java-font-lock-package {
          color: #0000cd;
          background-color: #faf0e6;
        } /* jde-java-font-lock-package-face */
        .jde-java-font-lock-constant {
          color: #5f9ea0;
          background-color: #faf0e6;
        } /* jde-java-font-lock-constant-face */
        .keyword {
          color: #8b0000;
          background-color: #faf0e6;
        } /* font-lock-keyword-face */
        .type {
          color: #4682b4;
          background-color: #faf0e6;
        } /* font-lock-type-face */
        .jde-java-font-lock-modifier {
          color: #da70d6;
          background-color: #faf0e6;
        } /* jde-java-font-lock-modifier-face */
        .function-name {
          color: #8b2323;
          background-color: #faf0e6;
        } /* font-lock-function-name-face */
        a {
          color: inherit;
          background-color: inherit;
          font: inherit;
          text-decoration: inherit;
        }
        a:hover {
          text-decoration: underline;
        }
      -->
      </style>
    </head>
    <body>
      <pre>
  <span class="keyword">package</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="jde-java-font-lock-package">properties</span>;
  
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">Numeric</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="jde-java-font-lock-package">expr</span>.<span class="type">PropertyException</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">PropertyValue</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="type">PropNames</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="type">FONode</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="jde-java-font-lock-package">properties</span>.<span class="type">BorderCommonWidth</span>;
  
  <span class="jde-java-font-lock-modifier">public</span> <span class="keyword">class</span> <span class="function-name" id="BorderLeftWidthClass">BorderLeftWidth</span> <span class="keyword">extends</span> <span class="type">BorderCommonWidth</span> {
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span> <span class="variable-name" id="dataTypes">dataTypes</span> = <span class="jde-java-font-lock-constant" id="LENGTH">LENGTH</span> | <span class="jde-java-font-lock-constant">MAPPED_LENGTH</span> | <span class="jde-java-font-lock-constant">INHERIT</span>;
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span> <span class="variable-name" id="traitMapping">traitMapping</span> = <span class="jde-java-font-lock-constant" id="DISAPPEARS">DISAPPEARS</span>;
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span> <span class="variable-name" id="initialValueType">initialValueType</span> = <span class="jde-java-font-lock-constant" id="LENGTH_IT">LENGTH_IT</span>;
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">PropertyValue</span> <span class="function-name" id="getInitialValue">getInitialValue</span>(<span class="type">int</span> <span class="variable-name" id="property">property</span>)
          <span class="keyword">throws</span> <span class="type">PropertyException</span>
      {
          <span class="keyword">return</span> getMappedLength(<span class="jde-java-font-lock-constant" id="null">null</span>, <span class="jde-java-font-lock-constant">MEDIUM</span>);
      }
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">Numeric</span> <span class="function-name" id="getMappedLength">getMappedLength</span>(<span class="type">FONode</span> <span class="variable-name" id="node">node</span>, <span class="type">int</span> <span class="variable-name">enum</span>)
          <span class="keyword">throws</span> <span class="type">PropertyException</span>
      {
          <span class="keyword">return</span> getMappedLength(node, PropNames.<span class="jde-java-font-lock-constant" id="BORDER_LEFT_WIDTH">BORDER_LEFT_WIDTH</span>, enum);
      }
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span> <span class="variable-name" id="inherited">inherited</span> = <span class="jde-java-font-lock-constant" id="NO">NO</span>;
  
  }
  
  </pre>
    </body>
  </html>
  
  
  
  1.1                  xml-site/targets/fop/design/alt.design/properties/Character.html
  
  Index: Character.html
  ===================================================================
  <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN">
  <!-- Created by htmlize-0.67 in css mode. -->
  <html>
    <head>
      <title>Character.java</title>
      <style type="text/css">
      <!--
        body {
          color: #000000;
          background-color: #faf0e6;
        } /* default */
        .variable-name {
          color: #8b008b;
          background-color: #faf0e6;
        } /* font-lock-variable-name-face */
        .jde-java-font-lock-package {
          color: #0000cd;
          background-color: #faf0e6;
        } /* jde-java-font-lock-package-face */
        .jde-java-font-lock-constant {
          color: #5f9ea0;
          background-color: #faf0e6;
        } /* jde-java-font-lock-constant-face */
        .keyword {
          color: #8b0000;
          background-color: #faf0e6;
        } /* font-lock-keyword-face */
        .type {
          color: #4682b4;
          background-color: #faf0e6;
        } /* font-lock-type-face */
        .jde-java-font-lock-modifier {
          color: #da70d6;
          background-color: #faf0e6;
        } /* jde-java-font-lock-modifier-face */
        .function-name {
          color: #8b2323;
          background-color: #faf0e6;
        } /* font-lock-function-name-face */
        a {
          color: inherit;
          background-color: inherit;
          font: inherit;
          text-decoration: inherit;
        }
        a:hover {
          text-decoration: underline;
        }
      -->
      </style>
    </head>
    <body>
      <pre>
  <span class="keyword">package</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="jde-java-font-lock-package">properties</span>;
  
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="jde-java-font-lock-package">expr</span>.<span class="type">PropertyException</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="jde-java-font-lock-package">properties</span>.<span class="type">Property</span>;
  
  <span class="jde-java-font-lock-modifier">public</span> <span class="keyword">class</span> <span class="function-name" id="CharacterClass">Character</span> <span class="keyword">extends</span> <span class="type">Property</span>  {
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span> <span class="variable-name" id="dataTypes">dataTypes</span> = <span class="jde-java-font-lock-constant" id="CHARACTER_T">CHARACTER_T</span>;
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span> <span class="variable-name" id="traitMapping">traitMapping</span> = <span class="jde-java-font-lock-constant" id="FORMATTING">FORMATTING</span>;
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span> <span class="variable-name" id="initialValueType">initialValueType</span> = <span class="jde-java-font-lock-constant" id="NOTYPE_IT">NOTYPE_IT</span>;
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span> <span class="variable-name" id="inherited">inherited</span> = <span class="jde-java-font-lock-constant" id="NO">NO</span>;
  }
  
  </pre>
    </body>
  </html>
  
  
  
  1.1                  xml-site/targets/fop/design/alt.design/properties/classes-overview.html
  
  Index: classes-overview.html
  ===================================================================
  <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" >
  <html>
    <head>
      <META http-equiv= "Content-Type" content= "text/html; charset=ISO-8859-1" >
      <title>Property classes overview</title>
      <link type="text/css" href="../../../page.css" rel="stylesheet">
    </head>
    <body marginheight= "0" marginwidth= "0" topmargin= "0" leftmargin= "0" text= "#000000" bgcolor= "#FFFFFF" >
      <div class= "content" >
        <h1>Property classes overview</h1>
        <p>
          <font size= "-2" >by&nbsp;Peter B. West</font>
        </p>
        <ul class= "minitoc" >
          <li>
            <a href = "#N10014" >Properties: packages</a>
            <ul class= "minitoc" >
              <li>
                <a href = "#N10019" >org.apache.fop.fo</a>
              </li>
              <li>
                <a href = "#N100AC" >org.apache.fop.fo.properties</a>
              </li>
              <li>
                <a href = "#N100EE" >org.apache.fop.fo.expr</a>
              </li>
              <li>
                <a href = "#N10134" >org.apache.fop.datatypes</a>
              </li>
              <li>
                <a href = "#N101A2"
                >org.apache.fop.datatypes.indirect</a>
              </li>
            </ul>
          </li>
        </ul>
        <a name= "N10014" ></a> <h3>Properties: packages</h3> <a name=
        "N10019" ></a> <h4>org.apache.fop.fo</h4>
        <dl>
          <dt>
            <a href = "javascript:parent.displayCode(
               'PropNames.html#PropNamesClass'
            )" ><em>PropNames</em></a>
          </dt>
          <dd>
            This class maintains an array of <a href=
            "javascript:parent.displayCode(
            'PropNames.html#propertyNames' )" >property names</a>,
            synchronized to a complete set of property name <a href =
            "javascript:parent.displayCode( 'PropNames.html#NO_PROPERTY'
            )" >constants</a> for indexing property-based arrays.  It
            includes methods to <a href =
            "javascript:parent.displayCode(
            'PropNames.html#getPropertyName' )" >convert an index to a
            name</a> and to <a href = "javascript:parent.displayCode(
            'PropNames.html#getPropertyIndex' )" >convert a property
            name to an index</a>.
          </dd>
          <dt>
            <a href = "PropertyConsts-class.html" ><em>PropertyConsts</em></a>
          </dt>
          <dd>
            A singleton instance of <span class= "codefrag"
            >PropertyConsts</span> is created by the static initializer
            of the <a href = "javascript:parent.displayCode(
            'PropertyConsts.html#pconsts' )" >pconsts</a> field.
            Working from the property indices defined in PropNames, the
            methods in this class collect and supply the values of
            fields defined in property objects into arrays.<br> The
            heart of this class in the method <a href =
            "javascript:parent.displayCode(
            'PropertyConsts.html#setupProperty' )" >setupProperty</a>,
            which constructs the property name from the index,
            instantiates a singleton of the appropriate class, and
            extracts static fields by reflection from that instance into
            the arrays of field values.
          </dd>
          <dt>
            <a href = "javascript:parent.displayCode(
            'PropertySets.html#PropertySetsClass' )" ><em>PropertySets</em></a>
          </dt>
          <dd>
            This class provides a number of <span class= "codefrag"
            >ROBitSet</span>s representing many of the sets of
            properties defined in <em>Section 7</em> of the
            specification.  Note that the <a
            href="javascript:parent.displayCode(
            'PropertySets.html#borderProps' )"><em>Border</em></a>, <a
            href="javascript:parent.displayCode(
            'PropertySets.html#paddingProps' )"><em>Padding</em></a> and
            <a href="javascript:parent.displayCode(
            'PropertySets.html#backgroundProps'
            )"><em>Background</em></a> sets are defined separately.
          </dd>
          <dt>
            <a href = "javascript:parent.displayCode(
            '../FOPropertySets.html#FOPropertySetsClass' )"
            ><em>FOPropertySets</em></a>
          </dt>
          <dd>
            This class provides a number of <span class= "codefrag"
            >ROBitSet</span>s representing sets of properties which are
            applicable in particular subtrees of the FO tree.  These
            sets are provided so that other properties can be ignored
            during processing of the subtrees.
          </dd>
          <dt>
            <a href = "javascript:parent.displayCode(
            'ShorthandPropSets.html#ShorthandPropSetsClass' )"
            ><em>ShorthandPropSets</em></a>
          </dt>
          <dd>
            This class contains arrays of <a href =
            "javascript:parent.displayCode(
            'ShorthandPropSets.html#shorthands' )" >shorthand property
            indices</a> and <a href = "javascript:parent.displayCode(
            'ShorthandPropSets.html#compounds' )" >compound property
            indices</a>, and <span class= "codefrag" >ROBitSet</span>s
            representing the expansion sets of these shorthands and
            compounds.  Various methods useful in the expansion of these
            properties are also included.
          </dd>
          <dt>
            <a href = "javascript:parent.displayCode(
            'FOAttributes.html#FOAttributesClass' )"
            ><em>FOAttributes</em></a>
          </dt>
          <dd>
            This class manages the attribute set that is associated with
            a SAX <span class= "codefrag" >startElement</span> event.
            <em>fo:</em> namespace attributes are entered into a <a href
            = "javascript:parent.displayCode(
            'FOAttributes.html#foAttrMap' )"><span class= "codefrag"
            >HashMap</span></a>, indexed by the <em>fo:</em> property
            index.  As other namespaces are encountered, the values are
            entered into namespace-specific <a href =
            "javascript:parent.displayCode(
            'FOAttributes.html#nSpaceAttrMaps' )"><span class=
            "codefrag" >HashMap</span>s</a>, indexed by the <em>local
            name</em> of the attribute.
          </dd>
        </dl>
        <a name= "N100AC" ></a><a name= "property-classes" ></a>
        <h4>org.apache.fop.fo.properties</h4>
        <dl>
          <dt>
            <a href="javascript:parent.displayCode(
            'Property.html#PropertyClass' )" ><em>Property</em></a>
          </dt>
          <dd>
            The base class for all individual property classes.
            There are 320 properties in all.
          </dd>
          <dt>
            <em>ColumnNumber</em>
          </dt>
          <dd>
            The actual property class with the lowest index
            number, followed in the index order by properties required
            for further processing, e.g. FontSize.
          </dd>
          <dt>
            <em>....</em>
          </dt>
          <dd>....</dd>
          <dt>
            <em>Background</em>
          </dt>
          <dd>
            First in index order of the remainining shorthand
            properties, followed in index order by all other remaining
            shorthands.
          </dd>
          <dt>
            <em>....</em>
          </dt>
          <dd>....</dd>
          <dt>
            <em>AbsolutePosition</em>
          </dt>
          <dd>
            First in index order of the remaining properties.  Within
            this ordering, compound properties precede their expansion
            properties, and corresponding relative properties precede
            corresponding absolute properties.
          </dd>
          <dt>
            <em>....</em>
          </dt>
          <dd>....</dd>
          <dt>
            <em>ZIndex</em>
          </dt>
          <dd>
            The property class with the highest index
            number.
          </dd>
        </dl>
        <a name= "N100EE" ></a>
        <h4>org.apache.fop.fo.expr</h4>
        <dl>
          <dt>
            <a href = "javascript:parent.displayCode(
            'PropertyTokenizer.html#PropertyTokenizerClass' )"
            ><em>PropertyTokenizer</em></a>
          </dt>
          <dd>
            The tokenizer for the property expression parser.  Defines a
            set of <a href = "javascript:parent.displayCode(
            'PropertyTokenizer.html#EOF' )" >token constants</a> and
            returns these with associated token values.
          </dd>
          <dt>
            <a href = "javascript:parent.displayCode(
            'PropertyParser.html#PropertyParserClass' )"
            ><em>PropertyParser</em></a>
          </dt>
          <dd>
            This extends <span class= "codefrag"
            >PropertyTokenizer</span>.  It parses property
            expressions on the basis of the tokens passed to it by its
            superclass, generating <span class= "codefrag"
            >PropertyValue</span>s, including <span class= "codefrag"
            >PropertyValueList</span>s.
          </dd>
          <dt>
            <em>PropertyException</em>
          </dt>
          <dd>
            The basic class for all property-related exceptions.
            It extends <span class= "codefrag" >FOPException</span>. It
            is housed in this package by historical accident.
          </dd>
          <dt>
            <em>DataTypeNotImplementedException</em>
            <br>
            <em>FunctionNotImplementedException</em>
            <br>
            <em>PropertyNotImplementedException</em>
          </dt>
          <dd>
            A set of particular exceptions extending <span class=
            "codefrag" >PropertyException</span>.  Also in this package
            by accident.
          </dd>
        </dl>
        <a name= "N10134" ></a>
        <h4>org.apache.fop.datatypes</h4>
        <dl>
          <dt>
            <a href = "javascript:parent.displayCode(
            'PropertyValue.html#PropertyValueInterface' )"
            ><em>PropertyValue</em></a>
          </dt>
          <dd>
            An <em>interface</em> which all <span class= "codefrag"
            >PropertyValue</span> classes must implement.  In addition
            to a few methods, <span class= "codefrag"
            >PropertyValue</span> defines the set of <a href =
            "javascript:parent.displayCode( 'PropertyValue.html#NO_TYPE'
            )" >constants</a> which the <span class= "codefrag"
            >getType()</span> method may return; i.e. the valid set of
            <span class= "codefrag" >PropertyValue</span> types.
          </dd>
          <dt>
            <a href = "javascript:parent.displayCode(
            'AbstractPropertyValue.html#AbstractPropertyValueClass' )"
            ><em>AbstractPropertyValue</em></a>
          </dt>
          <dd>
            An abstract implementation of the <span class= "codefrag"
            >PropertyValue</span> interface.  Most actual property value
            classes extend <span class= "codefrag"
            >AbstractPropertyValue</span>.
          </dd>
          <dt>
            <a href = "javascript:parent.displayCode(
            'PropertyValueList.html#PropertyValueListClass' )"
            ><em>PropertyValueList</em></a>
          </dt>
          <dd>
            This class extends <span class= "codefrag"
            >LinkedList</span> and implements <span class= "codefrag"
            >PropertyValue</span>.  It is used whenever the process of
            resolving a property expression yields a list of <span
            class= "codefrag" >PropertyValue</span> elements; notably
            during the processing of shorthands and "compound"
            properties.
          </dd>
          <dt>
            <em>StringType</em>
          </dt>
          <dd>
            A basic type extending <span class= "codefrag"
            >AbstractPropertyValue</span>.  Extended by <span class=
            "codefrag" >NCName</span>.
          </dd>
          <dt>
            <em>NCName</em>
          </dt>
          <dd>
            Extends <span class= "codefrag" >StringType</span> to represent
            NCName strings.
          </dd>
          <dt>
            <em>EnumType</em>
          </dt>
          <dd>
            Extends <span class= "codefrag"
            >AbstractPropertyValue</span> to represented enumerated
            types.
          </dd>
          <dt>
            <em>Other types</em>
          </dt>
          <dd>
            All other types extend one of the above classes.
          </dd>
        </dl>
        <a name= "N101A2" ></a>
        <h4>org.apache.fop.datatypes.indirect</h4>
        <dl>
          <dt>
            <em>IndirectValue</em>
          </dt>
          <dd>
            The base type for all indirect value types; extends
            <span class= "codefrag" >AbstractPropertyValue</span>.
          </dd>
        </dl>
        <p>
          <strong>Previous:</strong> <a href = "introduction.html"
          >Introduction</a>
        </p>
        <p>
          <strong>Next:</strong> <a href= "PropertyConsts-class.html"
                                       >The PropertyConsts class</a>
        </p>
      </div>
      
      <table summary= "footer" cellspacing= "0" cellpadding= "0" width= "100%" height= "20" border= "0" >
          <tr>
            <td colspan= "2" height= "1" bgcolor= "#4C6C8F" ><img
            height= "1" width= "1" alt= "" src=
            "../../skin/images/spacer.gif" ><a href =
            "../../skin/images/label.gif" ></a><a href =
            "../../skin/images/page.gif" ></a><a href =
            "../../skin/images/chapter.gif" ></a><a href =
            "../../skin/images/chapter_open.gif" ></a><a href =
            "../../skin/images/current.gif" ></a><a href =
            "../..//favicon.ico" ></a></td>
          </tr>
          <tr>
            <td colspan= "2" bgcolor= "#CFDCED" class= "copyright"
            align= "center" ><font size= "2" face= "Arial, Helvetica,
            Sans-Serif" >Copyright &copy; 1999-2002&nbsp;The Apache
            Software Foundation. All rights reserved.<script type=
            "text/javascript" language= "JavaScript" ><!--
            document.write(" - "+"Last Published: " +
            document.lastModified); // --></script></font></td>
          </tr>
          <tr>
            <td align= "left" bgcolor= "#CFDCED" class= "logos"
            ></td><td align= "right" bgcolor= "#CFDCED" class= "logos"
            ></td>
          </tr>
      </table>
    </body>
  </html>
  
  
  
  1.1                  xml-site/targets/fop/design/alt.design/properties/Direction.html
  
  Index: Direction.html
  ===================================================================
  <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN">
  <!-- Created by htmlize-0.67 in css mode. -->
  <html>
    <head>
      <title>Direction.java</title>
      <style type="text/css">
      <!--
        body {
          color: #000000;
          background-color: #faf0e6;
        } /* default */
        .variable-name {
          color: #8b008b;
          background-color: #faf0e6;
        } /* font-lock-variable-name-face */
        .jde-java-font-lock-package {
          color: #0000cd;
          background-color: #faf0e6;
        } /* jde-java-font-lock-package-face */
        .jde-java-font-lock-constant {
          color: #5f9ea0;
          background-color: #faf0e6;
        } /* jde-java-font-lock-constant-face */
        .keyword {
          color: #8b0000;
          background-color: #faf0e6;
        } /* font-lock-keyword-face */
        .string {
          color: #008b00;
          background-color: #faf0e6;
        } /* font-lock-string-face */
        .jde-java-font-lock-number {
          color: #bc8f8f;
          background-color: #faf0e6;
        } /* jde-java-font-lock-number-face */
        .type {
          color: #4682b4;
          background-color: #faf0e6;
        } /* font-lock-type-face */
        .jde-java-font-lock-modifier {
          color: #da70d6;
          background-color: #faf0e6;
        } /* jde-java-font-lock-modifier-face */
        .function-name {
          color: #8b2323;
          background-color: #faf0e6;
        } /* font-lock-function-name-face */
        a {
          color: inherit;
          background-color: inherit;
          font: inherit;
          text-decoration: inherit;
        }
        a:hover {
          text-decoration: underline;
        }
      -->
      </style>
    </head>
    <body>
      <pre>
  <span class="keyword">package</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="jde-java-font-lock-package">properties</span>;
  
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datastructs</span>.<span class="type">ROStringArray</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="jde-java-font-lock-package">expr</span>.<span class="type">PropertyException</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">PropertyValue</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">EnumType</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="type">PropNames</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="jde-java-font-lock-package">properties</span>.<span class="type">Property</span>;
  
  <span class="jde-java-font-lock-modifier">public</span> <span class="keyword">class</span> <span class="function-name" id="DirectionClass">Direction</span> <span class="keyword">extends</span> <span class="type">Property</span>  {
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span> <span class="variable-name" id="dataTypes">dataTypes</span> = <span class="jde-java-font-lock-constant" id="ENUM">ENUM</span> | <span class="jde-java-font-lock-constant">INHERIT</span>;
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span> <span class="variable-name" id="traitMapping">traitMapping</span> = <span class="jde-java-font-lock-constant" id="NEW_TRAIT">NEW_TRAIT</span>;
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span> <span class="variable-name" id="initialValueType">initialValueType</span> = <span class="jde-java-font-lock-constant" id="ENUM_IT">ENUM_IT</span>;
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span> <span class="variable-name" id="LTR">LTR</span> = <span class="jde-java-font-lock-number">1</span>;
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span> <span class="variable-name" id="RTL">RTL</span> = <span class="jde-java-font-lock-number">2</span>;
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">PropertyValue</span> <span class="function-name" id="getInitialValue">getInitialValue</span>(<span class="type">int</span> <span class="variable-name" id="property">property</span>)
          <span class="keyword">throws</span> <span class="type">PropertyException</span>
      {
          <span class="keyword">return</span> <span class="keyword">new</span> <span class="type">EnumType</span>(PropNames.<span class="jde-java-font-lock-constant" id="DIRECTION">DIRECTION</span>, <span class="jde-java-font-lock-constant">LTR</span>);
      }
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span> <span class="variable-name" id="inherited">inherited</span> = <span class="jde-java-font-lock-constant" id="COMPUTED">COMPUTED</span>;
  
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">String</span>[] <span class="variable-name" id="rwEnums">rwEnums</span> = {
          <span class="jde-java-font-lock-constant" id="null">null</span>
          ,&quot;<span class="string">ltr</span>&quot;
          ,&quot;<span class="string">rtl</span>&quot;
      };
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">int</span> <span class="function-name" id="getEnumIndex">getEnumIndex</span>(<span class="type">String</span> <span class="variable-name" id="enum">enum</span>) <span class="keyword">throws</span> <span class="type">PropertyException</span> {
          <span class="keyword">return</span> enumValueToIndex(enum, rwEnums);
      }
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">String</span> <span class="function-name" id="getEnumText">getEnumText</span>(<span class="type">int</span> <span class="variable-name" id="index">index</span>) {
          <span class="keyword">return</span> rwEnums[index];
      }
  }
  
  </pre>
    </body>
  </html>
  
  
  
  1.1                  xml-site/targets/fop/design/alt.design/properties/enumerated-values.html
  
  Index: enumerated-values.html
  ===================================================================
  <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
  <html>
    <head>
      <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
      <title>Enumerated Data Values</title>
      <link type="text/css" href="../../../page.css" rel="stylesheet">
    </head>
    <body marginheight="0" marginwidth="0" topmargin="0" leftmargin="0" text="#000000" bgcolor="#FFFFFF">
      <div class="content">
        <h1>Enumerated Data Values</h1>
        <ul class="minitoc">
          <li>
            <a href="#N1000C">Enumerated Data Values</a>
            <ul class="minitoc">
              <li>
                <a href="#N10020">Array representation</a>
              </li>
              <li>
                <a href="#N1005C">HashMap representation</a>
              </li>
              <li>
                <a href="#N1009D">
                  Factoring Out Common Enumeration Values
                </a>
              </li>
              <li>
                <a href="#N100DD">Mapped Numeric Values</a>
              </li>
            </ul>
          </li>
        </ul>
        
        <a name="N1000C"></a>
        <h3>Enumerated Data Values</h3>
        <p>
          Property classes which allow enumerated data types must encode
          integer constants representing the enumeration tokens, and
          must provide a way of translating between the tokens and the
          integers, and <em>vice versa</em>.  Depending on the number of
          tokens in an enumeration set, the mapping from token to
          integer is maintained in an array or a <span
          class="codefrag">HashMap</span>.  The switch-over point from
          array to <span class="codefrag">HashMap</span> was determined
          by some highly implementation-dependent testing to be in the
          region of four to five elements.
        </p>
        <p>
          Many properties share common sets of enumeration tokens,
          e.g. those which allow color values, and those applying to
          borders and padding.  A special case of enumerated value is
          the mapped numeric enumeration, in which a token maps to a
          Numeric value.  These situations are discussed below.
        </p>
        <a name="N10020"></a>
        <h4>Array representation</h4>
        <p>
          
          <a href= "javascript:parent.displayCode(
          'Direction.html#DirectionClass' )" ><span
          class="codefrag">org.apache.fop.fo.properties.Direction</span></a>
          is an example of a class which supports an enumerated value
          with a small set of tokens.  The <a href=
          "javascript:parent.displayCode( 'Direction.html#dataTypes' )"
          ><span class="codefrag">dataTypes</span></a> field contains
          the <a href= "javascript:parent.displayCode(
          'Property.html#NOTYPE' )" ><span class="codefrag">ENUM</span>
          data type constant, defined in <span
          class="codefrag">Property</span></a>.  The enumeration integer
          constants are defined as <span class="codefrag">public static
          final int</span> values, <a href=
          "javascript:parent.displayCode( 'Direction.html#LTR') "><span
          class="codefrag' )" >LTR</span> and <span
          class="codefrag">RTL</span></a>.  Associating enumeration
          tokens with these integer constants occurs in the array <a
          href= "javascript:parent.displayCode( 'Direction.html#rwEnums'
          )" ><span class="codefrag">String[] rwEnums</span></a>, which
          is initialized with the token strings.  By convention, zero is
          never used to represent a valid enumeration constant, anywhere
          in this code.  It is, of course, critical that synchronization
          between <span class="codefrag">rwEnums</span> and the
          enumeration constants be maintained.
        </p>
        <p>
          The publicly accessible mapping from enumeration token to
          enumeration constant is achieved through the method <a href=
          "javascript:parent.displayCode( 'Direction.html#getEnumIndex'
          )" ><span class="codefrag">int
          getEnumIndex(String)</span></a>.  The corresponding mapping
          from enumeration constant to enumeration token is achieved
          through the method <a href= "javascript:parent.displayCode(
          'Direction.html#getEnumText' )" ><span class="codefrag">String
          getEnumText(int)</span></a>.
        </p>
        <a name="N1005C"></a>
        <h4>HashMap representation</h4>
        <p>
          
          <a href= "javascript:parent.displayCode(
          'RenderingIntent.html#RenderingIntentClass' )" ><span
          class="codefrag"
          >org.apache.fop.fo.properties.RenderingIntent</span ></a> is
          an example of a class which supports an enumerated value with
          a larger set of tokens.  The <a href=
          "javascript:parent.displayCode(
          'RenderingIntent.html#dataTypes' )" ><span
          class="codefrag">dataTypes</span></a> field contains the <a
          href= "javascript:parent.displayCode( 'Property.html#NOTYPE'
          )" ><span class="codefrag">ENUM</span> data type constant,
          defined in <span class="codefrag">Property</span></a>.
          Enumeration integer constants are defined as <a href=
          "javascript:parent.displayCode(
          'RenderingIntent.html#PERCEPTUAL' )" ><span
          class="codefrag">public static final int</span></a> values.
          Zero is never used to represent a valid enumeration constant.
          The enumeration tokens are stored in the array <a href=
          "javascript:parent.displayCode( 'RenderingIntent.html#rwEnums'
          )" ><span class="codefrag">String[] rwEnums</span></a>, which
          is initialized with the token strings.  Association of
          enumeration tokens with the integer constants occurs in the
          <span class="codefrag">HashMap</span> <a href=
          "javascript:parent.displayCode(
          'RenderingIntent.html#rwEnumHash"><span class="codefrag' )" >
          rwEnumHash</span></a>, which is initialized from the token
          array in a <span class="codefrag">static {}</span>
          initializer.  It is, of course, critical that synchronization
          between <span class="codefrag">rwEnums</span> and the
          enumeration constants be maintained.
        </p>
        <p>
          The publicly accessible mapping from enumeration token to
          enumeration constant is achieved through the method <a href=
          "javascript:parent.displayCode(
          'RenderingIntent.html#getEnumIndex' )" ><span
          class="codefrag">int getEnumIndex(String)</span></a>.  The
          corresponding mapping from enumeration constant to enumeration
          token is achieved through the method <a href=
          "javascript:parent.displayCode(
          'RenderingIntent.html#getEnumText' )" ><span
          class="codefrag">String getEnumText(int)</span></a>.
        </p>
        <a name="N1009D"></a>
        <h4 id="common-enum-values">
          Factoring Out Common Enumeration Values
        </h4>
        <p>
          When a number of properties support a common enumerated value,
          that value and its associated access methods may be factored
          out to a new class, which each of the properties then extends.
          An example of such a common super-class is <a href=
          "javascript:parent.displayCode(
          'BorderCommonStyle.html#BorderCommonStyleClass' )" ><span
          class="codefrag">BorderCommonStyle</span></a>.  Like a
          property with a normal HashMap representation of an enumerated
          value, BorderCommonStyle defines <a href=
          "javascript:parent.displayCode(
          'BorderCommonStyle.html#HIDDEN' )" ><span
          class="codefrag">public static final int</span></a>
          enumeration integer constants.  Similarly, the enumeration
          tokens are stored in the array <a href=
          "javascript:parent.displayCode(
          'BorderCommonStyle.html#rwEnums' )" ><span
          class="codefrag">String[] rwEnums</span></a>, and the
          association of enumeration tokens with the integer constants
          occurs in the <span class="codefrag">HashMap</span> <a href=
          "javascript:parent.displayCode(
          'BorderCommonStyle.html#rwEnumHash' )" ><span
          class="codefrag"> rwEnumHash</span></a>, initialized in a
          <span class="codefrag">static {}</span> initializer.  The
          mapping methods <a href= "javascript:parent.displayCode(
          'BorderCommonStyle.html#getEnumIndex' )" ><span
          class="codefrag">int getEnumIndex(String)</span></a> and <a
          href= "javascript:parent.displayCode(
          'BorderCommonStyle.html#getEnumText' )" ><span
          class="codefrag">String getEnumText(int)</span></a> are also
          present.
        </p>
        <p>
          Notice, however, that the class has none of the static data
          constants described in the discussion of <a
          href="simple-properties.html">simple properties</a>.  These
          values are defined in the individual sub-classes of this
          class, e.g. <a href= "javascript:parent.displayCode(
          'BorderLeftStyle.html#BorderLeftStyleClass' )" ><span
          class="codefrag">BorderLeftStyle</span></a>.  None of the
          above fields or methods occur, and <span
          class="codefrag">BorderLeftStyle</span> is left looking like
          an example of a simple property.  The enumeration mapping
          methods are, however, available through the super-class <span
          class="codefrag">BorderCommonStyle</span>.
        </p>
        <a name="N100DD"></a>
        <h4>Mapped Numeric Values</h4>
        <p>
          In "normal" enumerated values, the token is, effectively,
          passed directly into the layout operation of the flow object
          to which the property is applied.  Some enumerated values,
          however, generate a <span class="codefrag">Numeric</span>
          result.  Their resolution involves mapping the token to the
          indicated <span class="codefrag">Numeric</span> value.
        </p>
        <p>
          An example is the <a href= "javascript:parent.displayCode(
          'BorderCommonWidth.html#BorderCommonWidthClass' )" ><span
          class="codefrag">BorderCommonWidth</span></a> property.  This,
          like the example of <a href="#common-enum-values"><span
          class="codefrag">BorderCommonStyle</span></a> above, also
          represents common enumerated values which have been factored
          out to form a super-class for particular properties.  <span
          class="codefrag">BorderCommonWidth</span>, therefore, also
          defines <a href= "javascript:parent.displayCode(
          'BorderCommonWidth.html#THIN' )" ><span
          class="codefrag">enumeration constant values</span></a> and an
          array of tokens.  In this case, there is no <span
          class="codefrag">HashMap</span>, because of the limited number
          of tokens, but the mapping methods <a href=
          "javascript:parent.displayCode(
          'BorderCommonWidth.html#getEnumIndex' )" ><span
          class="codefrag">int getEnumIndex(String)</span></a> and <a
          href= "javascript:parent.displayCode(
          'BorderCommonWidth.html#getEnumText' )" ><span
          class="codefrag">String getEnumText(int)</span></a> are
          present.
        </p>
        <p>
          The added element in this property is the array <a href=
          "javascript:parent.displayCode(
          'BorderCommonWidth.html#mappedPoints' )" ><span
          class="codefrag">double[] mappedPoints</span></a>.  The
          entries in this array must by maintained in syncronization
          with the <a href= "javascript:parent.displayCode(
          'BorderCommonWidth.html#rwEnums' )" ><span
          class="codefrag">String[] rwEnums</span></a> array of tokens
          and the set of <a href= "javascript:parent.displayCode(
          'BorderCommonWidth.html#THIN' )" >enumeration constants</a>.
          The mapping from token to Numeric value is achieved by the <a
          href= "javascript:parent.displayCode(
          'BorderCommonWidth.html#getMappedLength' )" ><span
          class="codefrag">Numeric getMappedLength(FONode, int,
          int)</span></a> method.
        </p>
        <p>
          
          <a href= "javascript:parent.displayCode(
          'BorderLeftWidth.html#BorderLeftWidthClass' )" ><span
          class="codefrag">BorderLeftWidth</span></a> extends <a href=
          "javascript:parent.displayCode( 'BorderCommonWidth.html' )"
          ><span class="codefrag">BorderCommonWidth</span></a>.  It
          includes the basic static data, like <a
          href="simple-properties.html">simple properties</a>, and, in
          this case, the <a href= "javascript:parent.displayCode(
          'BorderLeftWidth.html#getInitialValue' )" ><span
          class="codefrag">PropertyValue getInitialValue(int)</span></a>
          method to derive the initial value.
        </p>
        <a name="N10139"></a>
        <h4>Deriving Mapped Numeric Values</h4>
        <p>
          As usual with property values, the usual method of deriving a
          mapped numeric value is by calling the <a href=
          "javascript:parent.displayCode(
          '../PropertyConsts.html#getMappedNumeric' )" ><span
          class="codefrag">Numeric getMappedNumeric(FONode, int,
          int)</span></a> method in <a href=
          "javascript:parent.displayCode(
          '../PropertyConsts.html#pconsts' )" ><span
          class="codefrag">pconsts</span></a>.  All properties which
          support a mapped numeric value must have a <span
          class="codefrag">Numeric getMappedNumeric(FONode, int)</span>
          method, which will be called through its singleton instance,
          stored in the <a href= "javascript:parent.displayCode(
          'PropertyConsts.html#properties' )" ><span class= "codefrag"
          >properties</span ></a> array, by the <span
          class="codefrag">PropertyConsts</span> method.
        </p>
  
        <p>
          <strong>Previous:</strong> <a href= "getInitialValue.html"
                                    >getInitialValue()</a>
        </p>
        <!--
        <p>
          <strong>Next:</strong> <a href= "getInitialValue.html"
                                    >getInitialValue()</a>
        </p>
  -->
        
      </div>
      <table summary="footer" cellspacing="0" cellpadding="0" width="100%" height="20" border="0">
          <tr>
            <td colspan="2" height="1" bgcolor="#4C6C8F"><img height="1"
            width="1" alt="" src="../../../skin/images/spacer.gif"><a
            href="../../../skin/images/label.gif"></a><a
            href="../../../skin/images/page.gif"></a><a
            href="../../../skin/images/chapter.gif"></a><a
            href="../../../skin/images/chapter_open.gif"></a><a
            href="../../../skin/images/current.gif"></a><a
            href="../../..//favicon.ico"></a></td>
          </tr>
          <tr>
            <td colspan="2" bgcolor="#CFDCED" class="copyright"
            align="center"><font size="2" face="Arial, Helvetica,
            Sans-Serif">Copyright &copy; 1999-2002&nbsp;The Apache
            Software Foundation. All rights reserved.<script
            type="text/javascript" language="JavaScript"><!--
            document.write(" - "+"Last Published: " +
            document.lastModified); // --></script></font></td>
          </tr>
          <tr>
            <td align="left" bgcolor="#CFDCED" class="logos"></td><td
            align="right" bgcolor="#CFDCED" class="logos"></td>
          </tr>
      </table>
    </body>
  </html>
  
  
  
  1.1                  xml-site/targets/fop/design/alt.design/properties/FOAttributes.html
  
  Index: FOAttributes.html
  ===================================================================
  <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN">
  <!-- Created by htmlize-0.67 in css mode. -->
  <html>
    <head>
      <title>FOAttributes.java</title>
      <style type="text/css">
      <!--
        body {
          color: #000000;
          background-color: #faf0e6;
        } /* default */
        .jde-java-font-lock-number {
          color: #bc8f8f;
          background-color: #faf0e6;
        } /* jde-java-font-lock-number-face */
        .function-name {
          color: #8b2323;
          background-color: #faf0e6;
        } /* font-lock-function-name-face */
        .jde-java-font-lock-italic {
          background-color: #faf0e6;
          font-style: italic;
        } /* jde-java-font-lock-italic-face */
        .jde-java-font-lock-modifier {
          color: #da70d6;
          background-color: #faf0e6;
        } /* jde-java-font-lock-modifier-face */
        .keyword {
          color: #8b0000;
          background-color: #faf0e6;
        } /* font-lock-keyword-face */
        .variable-name {
          color: #8b008b;
          background-color: #faf0e6;
        } /* font-lock-variable-name-face */
        .string {
          color: #008b00;
          background-color: #faf0e6;
        } /* font-lock-string-face */
        .jde-java-font-lock-package {
          color: #0000cd;
          background-color: #faf0e6;
        } /* jde-java-font-lock-package-face */
        .jde-java-font-lock-constant {
          color: #5f9ea0;
          background-color: #faf0e6;
        } /* jde-java-font-lock-constant-face */
        .type {
          color: #4682b4;
          background-color: #faf0e6;
        } /* font-lock-type-face */
        .jde-java-font-lock-doc-tag {
          color: #008b00;
          background-color: #faf0e6;
        } /* jde-java-font-lock-doc-tag-face */
        .comment {
          color: #00008b;
          background-color: #faf0e6;
        } /* font-lock-comment-face */
        .reference {
          color: #cd0000;
          background-color: #faf0e6;
        } /* font-lock-reference-face */
        a {
          color: inherit;
          background-color: inherit;
          font: inherit;
          text-decoration: inherit;
        }
        a:hover {
          text-decoration: underline;
        }
      -->
      </style>
    </head>
    <body>
      <pre>
  <span class="keyword">package</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>;
  
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">apps</span>.<span class="type">FOPException</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="jde-java-font-lock-package">expr</span>.<span class="type">PropertyException</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="type">PropertyConsts</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="type">FObjectNames</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">Ints</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">messaging</span>.<span class="type">MessageHandler</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">xml</span>.<span class="type">FoXMLEvent</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">xml</span>.<span class="type">XMLNamespaces</span>;
  
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">xml</span>.<span class="jde-java-font-lock-package">sax</span>.<span class="type">Attributes</span>;
  
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">java</span>.<span class="jde-java-font-lock-package">util</span>.<span class="type">Iterator</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">java</span>.<span class="jde-java-font-lock-package">util</span>.<span class="type">ArrayList</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">java</span>.<span class="jde-java-font-lock-package">util</span>.<span class="type">HashMap</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">java</span>.<span class="jde-java-font-lock-package">util</span>.<span class="type">List</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">java</span>.<span class="jde-java-font-lock-package">util</span>.<span class="type">Map</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">java</span>.<span class="jde-java-font-lock-package">util</span>.<span class="type">Collections</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">java</span>.<span class="jde-java-font-lock-package">util</span>.<span class="type">Arrays</span>;
  
  <span class="comment">/*
   * FOAttributes.java
   * $Id: FOAttributes.html,v 1.1 2003/01/24 10:46:48 pbwest Exp $
   *
   * Created: Wed Nov 14 15:19:51 2001
   * Copyright (C) 2001 The Apache Software Foundation. All rights reserved.
   * For details on use and redistribution please refer to the
   * LICENSE file included with these sources.
   *
   * @author &lt;a href=&quot;mailto:pbwest@powerup.com.au&quot;&gt;Peter B. West&lt;/a&gt;
   * @version $Revision: 1.1 $ $Name:  $
   */</span>
  <span class="comment">/**
   * The FO Attributes data structures and methods needed to manage the
   * Attributes associated with FO nodes.
   */</span>
  
  <span class="jde-java-font-lock-modifier">public</span> <span class="keyword">class</span> <span class="function-name" id="FOAttributesClass">FOAttributes</span> {
  
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">String</span> <span class="variable-name" id="tag">tag</span> = &quot;<span class="string">$Name:  $</span>&quot;;
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">String</span> <span class="variable-name" id="revision">revision</span> = &quot;<span class="string">$Revision: 1.1 $</span>&quot;;
  
      <span class="comment">/**
       * &lt;i&gt;</span><span class="jde-java-font-lock-italic">nSpaceAttrMaps</span><span class="comment">&lt;/i&gt; is an &lt;tt&gt;ArrayList&lt;/tt&gt; to hold the array of 
       * &lt;tt&gt;HashMap&lt;/tt&gt;s which contain the attribute lists for each
       * namespace which may be active for a particular FO element.  The
       * &lt;tt&gt;ArrayList&lt;/tt&gt; is indexed by the URIIndex for this namespace
       * which is maintained in an &lt;tt&gt;XMLNamespaces&lt;/tt&gt; object by the
       * &lt;tt&gt;FOTree&lt;/tt&gt; object which is processing the FO input.  The
       * values in the &lt;tt&gt;HashMap&lt;/tt&gt;s are indexed by the local name of the
       * attribute.
       * The &lt;tt&gt;ArrayList&lt;/tt&gt; will not be created for a particular instance
       * of &lt;tt&gt;FOAttributes&lt;/tt&gt; unless a namespace other than the standard
       * XSL namespace is activated for this instance.
       * See &lt;i&gt;</span><span class="jde-java-font-lock-italic">foAttrMap</span><span class="comment">&lt;/i&gt;.
       */</span>
      <span class="jde-java-font-lock-modifier">private</span> <span class="type">ArrayList</span> <span class="variable-name" id="nSpaceAttrMaps">nSpaceAttrMaps</span>;
  
      <span class="comment">/**
       * &lt;i&gt;</span><span class="jde-java-font-lock-italic">foAttrMap</span><span class="comment">&lt;/i&gt; is a &lt;tt&gt;HashMap&lt;/tt&gt; to hold the FO namespace
       * attribute list specified in the FO element with which this list is
       * associated.  The &lt;tt&gt;String&lt;/tt&gt; attribute value is stored
       * indexed by the integer constant property identifier from
       * &lt;tt&gt;PropertyConsts&lt;/tt&gt;.
       */</span>
      <span class="jde-java-font-lock-modifier">private</span> <span class="type">HashMap</span> <span class="variable-name" id="foAttrMap">foAttrMap</span> = <span class="keyword">new</span> <span class="type">HashMap</span>(<span class="jde-java-font-lock-number">0</span>);
  
      <span class="comment">/**
       * A sorted array of the keys (property indices) of the values in
       * &lt;i&gt;</span><span class="jde-java-font-lock-italic">foAttrMap</span><span class="comment">&lt;/i&gt;.
       */</span>
      <span class="jde-java-font-lock-modifier">private</span> <span class="type">Integer</span>[] <span class="variable-name" id="foAttrKeys">foAttrKeys</span> = <span class="jde-java-font-lock-constant" id="null">null</span>;
  
      <span class="comment">/**
       * A static array of &lt;tt&gt;Integer&lt;/tt&gt; as a template for the generation
       * of the &lt;i&gt;</span><span class="jde-java-font-lock-italic">foAttrKeys</span><span class="comment">&lt;/i&gt; array.
       */</span>
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="type">Integer</span>[] <span class="variable-name" id="integerArray">integerArray</span>
                                      = <span class="keyword">new</span> <span class="type">Integer</span>[] { Ints.consts.get(<span class="jde-java-font-lock-number">0</span>) };
  
      <span class="comment">/**
       * Construct an &lt;i&gt;</span><span class="jde-java-font-lock-italic">FOAttributes</span><span class="comment">&lt;/i&gt; object.
       * &lt;p&gt;The &lt;tt&gt;Attributes&lt;/tt&gt; object on the event is scanned, and each
       * attribute is examined.  If the attribute is in the default namespace
       * for fo: attributes, it is an fo: property, and its value is entered
       * into the &lt;i&gt;</span><span class="jde-java-font-lock-italic">foAttrMap</span><span class="comment">&lt;/i&gt; &lt;tt&gt;Hashmap&lt;/tt&gt; indexed by the property
       * index.
       * &lt;p&gt;If the attribute does not belong to the default namespace, its
       * value is entered into the appropriate &lt;tt&gt;HashMap&lt;/tt&gt; in the
       * &lt;tt&gt;ArrayList&lt;/tt&gt; &lt;i&gt;</span><span class="jde-java-font-lock-italic">nSpaceAttrMaps</span><span class="comment">&lt;/i&gt;, indexed by the attribute's
       * local name.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="event">event</span><span class="comment"> - the FO XML event which triggered construction of the
       * parent &lt;tt&gt;FONode&lt;/tt&gt;.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="foNode">foNode</span><span class="comment"> - the &lt;tt&gt;FONode&lt;/tt&gt; with which these attributes are
       * associated.
       */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="function-name" id="FOAttributes">FOAttributes</span>(<span class="type">FoXMLEvent</span> <span class="variable-name">event</span>, <span class="type">FONode</span> <span class="variable-name">foNode</span>) <span class="keyword">throws</span> <span class="type">FOPException</span> {
  
          <span class="comment">// If the event is null, there is no event associated with this
  </span>        <span class="comment">// node, probably because this is a manufactured node; e.g.,
  </span>        <span class="comment">// an &quot;invented&quot; FopageSequenceMaster.  The default initialisation
  </span>        <span class="comment">// includes an empty foAttrMap HashMap.
  </span>        <span class="keyword">if</span> (event == <span class="jde-java-font-lock-constant">null</span>) <span class="keyword">return</span>;
  
          <span class="keyword">if</span> (event.getFoType() == FObjectNames.<span class="jde-java-font-lock-constant" id="PCDATA">PCDATA</span>)
              <span class="keyword">return</span>;  <span class="comment">// go with the empty foAttrMap
  </span>
          <span class="comment">// Create the foAttrMap.
  </span>        <span class="type">Attributes</span> <span class="variable-name" id="attributes">attributes</span> = event.getAttributes();
          <span class="keyword">if</span> (attributes == <span class="jde-java-font-lock-constant">null</span>) <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">FOPException</span>
                                         (&quot;<span class="string">No Attributes in XMLEvent</span>&quot;);
          <span class="type">int</span> <span class="variable-name" id="propIndex">propIndex</span>;
          <span class="type">HashMap</span> <span class="variable-name" id="tmpHash">tmpHash</span>;
          <span class="keyword">for</span> (<span class="type">int</span> <span class="variable-name" id="i">i</span> = <span class="jde-java-font-lock-number">0</span>; i &lt; attributes.getLength(); i++) {
              <span class="type">String</span> <span class="variable-name" id="attrUri">attrUri</span> = attributes.getURI(i);
              <span class="type">String</span> <span class="variable-name" id="attrLocalname">attrLocalname</span> = attributes.getLocalName(i);
              <span class="type">String</span> <span class="variable-name" id="attrQName">attrQName</span> = attributes.getQName(i);
              <span class="type">int</span> <span class="variable-name" id="sep">sep</span> = attrQName.indexOf('<span class="string">:</span>');
              <span class="type">String</span> <span class="variable-name" id="prefix">prefix</span> = attrQName.substring(<span class="jde-java-font-lock-number">0</span>, (sep == -<span class="jde-java-font-lock-number">1</span> ? <span class="jde-java-font-lock-number">0</span> : sep));
              <span class="keyword">if</span> (prefix.equals(&quot;<span class="string">xmlns</span>&quot;)) <span class="keyword">break</span>;
              <span class="type">String</span> <span class="variable-name" id="attrValue">attrValue</span> = attributes.getValue(i);
              <span class="type">int</span> <span class="variable-name" id="attrUriIndex">attrUriIndex</span> = foNode.namespaces.getURIIndex(attrUri);
  
              <span class="comment">//System.out.println(&quot;FONode:&quot; + event);
  </span>            <span class="keyword">if</span> (attrUriIndex == XMLNamespaces.DefAttrNSIndex) {
                  <span class="comment">// Standard FO namespace
  </span>                <span class="comment">// Catch default namespace declaration here.
  </span>                <span class="keyword">if</span> (attrLocalname.equals(&quot;<span class="string">xmlns</span>&quot;)) <span class="keyword">break</span>;
                  <span class="comment">// Is this a known (valid) property?
  </span>                propIndex = PropNames.getPropertyIndex(attrLocalname);
                      <span class="comment">// Known attribute name
  </span>                foAttrMap.put(Ints.consts.get(propIndex), attrValue);
              } <span class="keyword">else</span> { <span class="comment">// Not the XSL FO namespace
  </span>                <span class="type">int</span> <span class="variable-name" id="j">j</span>;
                  <span class="keyword">if</span> (nSpaceAttrMaps == <span class="jde-java-font-lock-constant">null</span>) {
                      <span class="comment">//Create the list
  </span>                    System.out.println(&quot;<span class="string">Creating nSpaceAttrMaps</span>&quot;);
                      nSpaceAttrMaps = <span class="keyword">new</span> <span class="type">ArrayList</span>(attrUriIndex + <span class="jde-java-font-lock-number">1</span>);
                      <span class="comment">// Add the fo list
  </span>                    <span class="keyword">for</span> (j = <span class="jde-java-font-lock-number">0</span>; j &lt; XMLNamespaces.DefAttrNSIndex; j++)
                          nSpaceAttrMaps.add(<span class="keyword">new</span> <span class="type">HashMap</span>(<span class="jde-java-font-lock-number">0</span>));
  
                      System.out.println(&quot;<span class="string">Adding foAttrMap</span>&quot;);
                      nSpaceAttrMaps.add(foAttrMap);
                  }
                  <span class="comment">// Make sure there are elements between the last current
  </span>                <span class="comment">// and the one to be added
  </span>                <span class="keyword">for</span> (j = nSpaceAttrMaps.size(); j &lt;= attrUriIndex; j++)
                      nSpaceAttrMaps.add(<span class="keyword">new</span> <span class="type">HashMap</span>(<span class="jde-java-font-lock-number">0</span>));
                  
                  <span class="comment">// Does a HashMap exist for this namespace?
  </span>                <span class="keyword">if</span> ((tmpHash =
                       (<span class="type">HashMap</span>)nSpaceAttrMaps.get(attrUriIndex)) == <span class="jde-java-font-lock-constant">null</span>) {
                      tmpHash = <span class="keyword">new</span> <span class="type">HashMap</span>(<span class="jde-java-font-lock-number">1</span>);
                      nSpaceAttrMaps.set(attrUriIndex, tmpHash);
                  }
                  <span class="comment">// Now put this value in the HashMap
  </span>                tmpHash.put(attrLocalname, attrValue);
              }
          }
          <span class="comment">// Set up the sorted array of the foAttr keys, if foAttrMap has
  </span>        <span class="comment">// any entries.
  </span>        <span class="keyword">if</span> (foAttrMap.size() &gt; <span class="jde-java-font-lock-number">0</span>) {
              foAttrKeys = (<span class="type">Integer</span>[])(foAttrMap.keySet().toArray(integerArray));
              Arrays.sort(foAttrKeys);
          }
          <span class="comment">// Finished with the Attributes object
  </span>        event.setAttributes(<span class="jde-java-font-lock-constant">null</span>);
      }
  
      <span class="comment">/**
       * Get the default namespace attribute values as an unmodifiable
       * &lt;tt&gt;Map&lt;/tt&gt;.
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> a unmodifiable &lt;tt&gt;Map&lt;/tt&gt; containing the the attribute
       * values for all of the default attribute namespace attributes in this
       * attribute list, indexed by the property name index from
       * &lt;tt&gt;PropNames&lt;/tt&gt;.
       */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">Map</span> <span class="function-name" id="getFixedFoAttrMap">getFixedFoAttrMap</span>() {
          <span class="keyword">return</span> Collections.unmodifiableMap((<span class="type">Map</span>)foAttrMap);
      }
  
      <span class="comment">/**
       * Get the &lt;tt&gt;HashMap&lt;/tt&gt; of all default namespace attributes.
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> &lt;tt&gt;HashMap&lt;/tt&gt; &lt;i&gt;</span><span class="jde-java-font-lock-italic">foAttrMap</span><span class="comment">&lt;/i&gt; containing the the attribute
       * values for all of the default attribute namespace attributes in this
       * attribute list, indexed by the property name index from
       * &lt;tt&gt;PropNames&lt;/tt&gt;.  This HashMap may be changed by the calling
       * process.
       */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">HashMap</span> <span class="function-name" id="getFoAttrMap">getFoAttrMap</span>() {
          <span class="keyword">return</span> foAttrMap;
      }
  
      <span class="comment">/**
       * Get the sorted array of property index keys for the default namespace
       * attributes.
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> &lt;tt&gt;Integer[]&lt;/tt&gt; &lt;i&gt;</span><span class="jde-java-font-lock-italic">foAttrKeys</span><span class="comment">&lt;/i&gt; containing the the
       * sorted keys (the property indices from &lt;tt&gt;PropNames&lt;/tt&gt;) of the
       * attribute values for all of the default attribute namespace attributes
       * in this attribute list.
       * Warning: This array may be changed by the calling process.
       */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">Integer</span>[] <span class="function-name" id="getFoAttrKeys">getFoAttrKeys</span>() {
          <span class="keyword">return</span> foAttrKeys;
      }
  
      <span class="comment">/**
       * A convenience method for accessing attribute values from the default
       * attribute namespace.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="property">property</span><span class="comment"> an &lt;tt&gt;int&lt;/tt&gt; containing the property name index
       * from &lt;tt&gt;PropNames&lt;/tt&gt;.
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> a &lt;tt&gt;String&lt;/tt&gt; containing the associated property value.
       */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">String</span> <span class="function-name" id="getFoAttrValue">getFoAttrValue</span>(<span class="type">int</span> <span class="variable-name">property</span>) {
          <span class="keyword">return</span> (<span class="type">String</span>)(foAttrMap.get(Ints.consts.get(property)));
      }
  
      <span class="comment">/**
       * A convenience method for accessing attribute values from the default
       * attribute namespace.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="propertyName">propertyName</span><span class="comment"> a &lt;tt&gt;String&lt;/tt&gt; containing the property name.
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> a &lt;tt&gt;String&lt;/tt&gt; containing the associated property value.
       */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">String</span> <span class="function-name">getFoAttrValue</span>(<span class="type">String</span> <span class="variable-name">propertyName</span>)
          <span class="keyword">throws</span> <span class="type">PropertyException</span>
      {
          <span class="keyword">return</span> getFoAttrValue(PropNames.getPropertyIndex(propertyName));
      }
  
      <span class="comment">/**
       * Get an unmodifiable &lt;tt&gt;Map&lt;/tt&gt; of the attribute values for a
       * particular namespace.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="uriIndex">uriIndex</span><span class="comment"> an &lt;tt&gt;int&lt;/tt&gt; containing the index of the attribute
       * values namespace, maintained in an &lt;tt&gt;XMLEvent&lt;/tt&gt; &lt;tt&gt;static&lt;/tt&gt;
       * array.
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> an unmodifiable &lt;tt&gt;Map&lt;/tt&gt; of the attribute values
       * within the indexed namespace, for this attribute list, indexed by the
       * local name of the attribute.  The &lt;tt&gt;Map&lt;/tt&gt; returned is
       * derived from the one maintained in &lt;i&gt;</span><span class="jde-java-font-lock-italic">nSpaceAttrMaps</span><span class="comment">&lt;/i&gt;.
       */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">Map</span> <span class="function-name" id="getAttrMap">getAttrMap</span>(<span class="type">int</span> <span class="variable-name">uriIndex</span>) {
          <span class="keyword">if</span> (uriIndex == XMLNamespaces.DefAttrNSIndex)
              <span class="keyword">return</span> Collections.unmodifiableMap((<span class="type">Map</span>)foAttrMap);
          <span class="keyword">if</span> (nSpaceAttrMaps != <span class="jde-java-font-lock-constant">null</span>) {
              <span class="keyword">if</span> (uriIndex &gt;= nSpaceAttrMaps.size()) <span class="keyword">return</span> <span class="jde-java-font-lock-constant">null</span>;
              <span class="keyword">return</span> Collections.unmodifiableMap
                      ((<span class="type">Map</span>)(nSpaceAttrMaps.get(uriIndex)));
          } <span class="keyword">else</span> {
              <span class="keyword">return</span> <span class="jde-java-font-lock-constant">null</span>;
          }
      }
  
      <span class="comment">/**
       * Get the value of an attribute in a particular namespace.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">uriIndex</span><span class="comment"> an &lt;tt&gt;int&lt;/tt&gt; index of the URIs maintained
       * by &lt;tt&gt;XMLEvent&lt;/tt&gt;.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="localName">localName</span><span class="comment"> a &lt;tt&gt;String&lt;/tt&gt; with the local name of the
       * attribute.  In the case of the default attribute namespace, this
       * will be the fo property name.
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> a &lt;tt&gt;String&lt;/tt&gt; containing the value of the attribute.
       */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">String</span> <span class="function-name" id="getUriAttrValue">getUriAttrValue</span>(<span class="type">int</span> <span class="variable-name">uriIndex</span>, <span class="type">String</span> <span class="variable-name">localName</span>)
          <span class="keyword">throws</span> <span class="type">PropertyException</span>
      {
          <span class="keyword">if</span> (uriIndex == XMLNamespaces.DefAttrNSIndex)
              <span class="keyword">return</span> getFoAttrValue(PropNames.getPropertyIndex(localName));
          <span class="keyword">return</span> (String)
                  (((<span class="type">HashMap</span>)nSpaceAttrMaps.get(uriIndex)).get(localName));
      }
  
      <span class="comment">/**
       * Get the size of the &lt;i&gt;</span><span class="jde-java-font-lock-italic">foAttrMap</span><span class="comment">&lt;/i&gt; &lt;tt&gt;HashMap&lt;/tt&gt;
       * containing attributes for the default fo: namespace
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> an &lt;tt&gt;int&lt;/tt&gt; containing the size.
       */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">int</span> <span class="function-name" id="getFoAttrMapSize">getFoAttrMapSize</span>() {
          <span class="keyword">return</span> foAttrMap.size();
      }
  
      <span class="comment">/**
       * Get the size of the &lt;i&gt;</span><span class="jde-java-font-lock-italic">nSpaceAttrMaps</span><span class="comment">&lt;/i&gt; &lt;tt&gt;ArrayList&lt;/tt&gt;
       * containing attribute namespaces active in this set of attributes.
       * &lt;i&gt;</span><span class="jde-java-font-lock-italic">N.B.</span><span class="comment">&lt;/i&gt; this may be zero if only the default attribute
       * namespace has been seen in the attribute set.
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> an &lt;tt&gt;int&lt;/tt&gt; containing the size.
       */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">int</span> <span class="function-name" id="getNSpaceAttrMapsSize">getNSpaceAttrMapsSize</span>() {
          <span class="keyword">if</span> (nSpaceAttrMaps == <span class="jde-java-font-lock-constant">null</span>)
              <span class="keyword">return</span> <span class="jde-java-font-lock-number">0</span>;
          <span class="keyword">return</span> nSpaceAttrMaps.size();
      }
  
      <span class="comment">/**
       * Merge attributes from another &lt;tt&gt;FOAttributes&lt;/tt&gt; into &lt;i&gt;</span><span class="jde-java-font-lock-italic">this</span><span class="comment">&lt;/i&gt;.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="foAttrs">foAttrs</span><span class="comment"> the &lt;tt&gt;FOAttributes&lt;/tt&gt; containing the attributes
       * to merge.
       */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">void</span> <span class="function-name" id="merge">merge</span>(<span class="type">FOAttributes</span> <span class="variable-name">foAttrs</span>) {
          foAttrMap.putAll(foAttrs.getFoAttrMap());
          <span class="type">int</span> <span class="variable-name" id="attrLen">attrLen</span> = foAttrs.getNSpaceAttrMapsSize();
          <span class="keyword">if</span> (attrLen != <span class="jde-java-font-lock-number">0</span>) {
              <span class="comment">// something to copy
  </span>            <span class="keyword">if</span> (nSpaceAttrMaps == <span class="jde-java-font-lock-constant">null</span>) {
                  <span class="comment">// no &quot;foreign&quot; attribute lists in this
  </span>                <span class="comment">// copy the others in
  </span>                nSpaceAttrMaps = <span class="keyword">new</span> <span class="type">ArrayList</span>(attrLen);
              }
              <span class="comment">// If the merging ArrayList of namespaces is larger, add the
  </span>            <span class="comment">// extra elements and initialise each to an empty HashMap
  </span>            <span class="keyword">for</span> (<span class="type">int</span> <span class="variable-name">i</span> = nSpaceAttrMaps.size(); i &lt; attrLen; i++)
                  nSpaceAttrMaps.add(<span class="keyword">new</span> <span class="type">HashMap</span>(<span class="jde-java-font-lock-number">0</span>));
              <span class="comment">// Except for foAttrs, which has already been merged, merge
  </span>            <span class="comment">// the entries from the merging foAttrs
  </span>            <span class="keyword">for</span> (<span class="type">int</span> <span class="variable-name">i</span> = <span class="jde-java-font-lock-number">0</span>; i &lt; attrLen; i++) {
                  <span class="comment">// skip foAttrMap
  </span>                <span class="keyword">if</span> (i == <span class="reference">XMLNamespaces</span>.<span class="type">DefAttrNSIndex</span>) <span class="keyword">continue</span>;
                 ((<span class="type">HashMap</span>) nSpaceAttrMaps.get(i))
                         .putAll(foAttrs.getAttrMap(i));
              }
          }
      }
  
  }<span class="comment">// FOAttributes
  </span></pre>
    </body>
  </html>
  
  
  
  1.1                  xml-site/targets/fop/design/alt.design/properties/getInitialValue.html
  
  Index: getInitialValue.html
  ===================================================================
  <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
  <html>
    <head>
      <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
      <title>Generating Initial Values</title>
      <link type="text/css" href="../../../page.css" rel="stylesheet">
    </head>
    <body marginheight="0" marginwidth="0" topmargin="0" leftmargin="0" text="#000000" bgcolor="#FFFFFF">
      <div class="content">
        <h1>Generating Initial Values</h1>
        <p>
          <font size="-2">by&nbsp;Peter B. West</font>
        </p>
        <ul class="minitoc">
          <li>
            <a href="#N10014">Introduction</a>
          </li>
          <li>
            <a href="#N10021">
              Generating &amp; Accessing Initial Values
            </a>
            <ul class="minitoc">
              <li>
                <a href="#N10062">Properties without
                  getInitialValue()</a>
              </li>
            </ul>
          </li>
        </ul>
        
        <a name="N10014"></a>
        <h3>Introduction</h3>
        <p>
          The <a href="simple-properties.html">previous section</a>
          discussed the common data elements in the simplest examples of
          property classes.  This section discusses more complex classes
          whose facilities are accessed only through various methods.
        </p>
        
        <a name="N10021"></a>
        <h3>
          Generating &amp; Accessing Initial Values
        </h3>
        <p>
          
          <a href= "javascript:parent.displayCode( 'AutoRestore.html' )"
          ><span class="codefrag"
          >org.apache.fop.fo.properties.AutoRestore</span></a> is an
          example of the next most complex property class.  In
          addition to all of the common static fields, these classes
          have initial data value types which require the dynamic
          generation of a PropertyValue instance.
        </p>
        <p>
          The method <a href= "javascript:parent.displayCode(
          'AutoRestore.html#getInitialValue' )" ><span
          class="codefrag">PropertyValue getInitialValue(int)</span></a>
          returns an instance of PropertyValue of the appropriate
          subclass containing the initial value for this property.  Like
          the static data fields, this value is, in turn, stored in the
          array of initial values maintained in the <a href=
          "javascript:parent.displayCode(
          'PropertyConsts.html#PropertyConstsClass' )" ><span
          class="codefrag">PropertyConsts</span></a> singleton <a href=
          "javascript:parent.displayCode( 'PropertyConsts.html#pconsts'
          )" ><span class="codefrag">pconsts</span></a>.` As with the
          fields, the first invocation of the method <a href=
          "javascript:parent.displayCode(
          'PropertyConsts.html#setupProperty' )" ><span
          class="codefrag">setupProperty</span></a> on the property
          instantiates the singleton instance of the class, and stores
          that instance in the in the <a href=
          "javascript:parent.displayCode(
          'PropertyConsts.html#properties' )" ><span
          class="codefrag">Property[] properties</span></a> array of <a
          href= "javascript:parent.displayCode(
          'PropertyConsts.html#pconsts' )" ><span
          class="codefrag">pconsts</span></a>.
        </p>
        <p>
          Unlike the static data fields, however, the initial value is
          not immediately generated.  It is generated by a call to <a
          href= "javascript:parent.displayCode(
          'PropertyConsts.html#getInitialValue' )" ><span
          class="codefrag">PropertyValue getInitialValue(int)</span></a>
          in <a href= "javascript:parent.displayCode(
          'PropertyConsts.html#pconsts' )" ><span
          class="codefrag">pconsts</span></a>.  This call, in turn,
          locates the relevant instance of the particular property class
          in the <a href= "javascript:parent.displayCode(
          'PropertyConsts.html#properties' )" ><span class= "codefrag"
          >properties</span> array of <span class= "codefrag"
          >PropertyConsts</span></a>, and invokes the <span class=
          "codefrag" >getInitialValue()</span> of that instance.  A
          side-effect of this call is to store the initial value in <a
          href= "javascript:parent.displayCode(
          'PropertyConsts.html#initialValues' )" ><span
          class="codefrag">PropertyValue[] initialValues</span></a>.
        </p>
        <a name="N10062"></a>
        <h4>Properties without
          getInitialValue()</h4>
        <p>
          What about property classes which have no <span
          class="codefrag">getInitialValue()</span> method?  The
          simplest classes, e.g. <span
          class="codefrag">Character</span>, fall into this category.
          As <a href="classes-overview.html#property-classes">noted
          previously</a>, all of the property classes extend <span
          class="codefrag">org.apache.fop.fo.properties.Property</span>.
          <a href= "javascript:parent.displayCode(
          'Property.html#PropertyClass' )" ><span
          class="codefrag">Property</span></a> provides a base <a href=
          "javascript:parent.displayCode(
          'Property.html#getInitialValue' )" ><span
          class="codefrag">PropertyValue getInitialValue(int)</span></a>
          method to which the simple classes fall back.  Note that it is
          only valid for <span class="codefrag">NOTYPE_IT</span>, <span
          class="codefrag">AUTO_IT</span>, <span
          class="codefrag">NONE_IT</span> and <span
          class="codefrag">AURAL_IT</span> initial value types, so all
          classes which have any other initial value type must override
          this method.
        </p>
  
        <p>
          <strong>Previous:</strong> <a href = "simple-properties.html"
          >Simple property classes</a>
        </p>
        <p>
          <strong>Next:</strong> <a href= "enumerated-values.html"
                                    >Enumerated values</a>
        </p>
        
      </div>
      <table summary="footer" cellspacing="0" cellpadding="0" width="100%" height="20" border="0">
          <tr>
            <td colspan="2" height="1" bgcolor="#4C6C8F"><img height="1"
            width="1" alt="" src="../../../skin/images/spacer.gif"><a
            href="../../../skin/images/label.gif"></a><a
            href="../../../skin/images/page.gif"></a><a
            href="../../../skin/images/chapter.gif"></a><a
            href="../../../skin/images/chapter_open.gif"></a><a
            href="../../../skin/images/current.gif"></a><a
            href="../../..//favicon.ico"></a></td>
          </tr>
          <tr>
            <td colspan="2" bgcolor="#CFDCED" class="copyright"
            align="center"><font size="2" face="Arial, Helvetica,
            Sans-Serif">Copyright &copy; 1999-2002&nbsp;The Apache
            Software Foundation. All rights reserved.<script
            type="text/javascript" language="JavaScript"><!--
            document.write(" - "+"Last Published: " +
            document.lastModified); // --></script></font></td>
          </tr>
          <tr>
            <td align="left" bgcolor="#CFDCED" class="logos"></td><td
            align="right" bgcolor="#CFDCED" class="logos"></td>
          </tr>
      </table>
    </body>
  </html>
  
  
  
  1.1                  xml-site/targets/fop/design/alt.design/properties/index.html
  
  Index: index.html
  ===================================================================
  <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Frameset//EN">
  <html>
    <head>
      <title>Alt Design Frameset</title>
      <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
      <script type="application/x-javascript">
        <!--
        var isHigh = true;
        
        function lengthenCol() {
          if (isHigh) { return; }
          fset = document.getElementById("altDesignFramesetRows");
          fset.setAttribute("rows", "95%,*");
          logowin = top.frames[0];
          logodoc = logowin.document;
          lbutton = logodoc.getElementById("lengthenButton");
          lbutton.setAttribute("value", "^");
          isHigh = true;
        }
        
        function shortenCol() {
          if ( ! isHigh) { return; }
          fset = document.getElementById("altDesignFramesetRows");
          fset.setAttribute("rows", "20%,*");
          logowin = top.frames[0];
          logodoc = logowin.document;
          lbutton = logodoc.getElementById("lengthenButton");
          lbutton.setAttribute("value", "v");
          isHigh = false;
        }
        
        function toggleColHeights() {
          if (isHigh) {
            shortenCol();
          } else {
            lengthenCol()
          }
        }
  
        function displayCode(src) {
            top.frames[2].location = src;
            shortenCol();
        }
  
        function displayHtml(src) {
            top.frames[1].location = src;
            lengthenCol();
        }
        -->
      </script>
    </head>
    <frameset id="altDesignFramesetCols" cols="180,*">
      <frame id="logoFrame" class="logo" style="padding: 0px; margin: 0px:
             border: 0px;" src="../logo.html" scrolling="no">
      <frameset id="altDesignFramesetRows" rows="95%,*">
        <frame id="contents" src="introduction.html">
        <frame id= "codeDisplayFrame"
               class= "codeDisplay"
               src= "../codeframe.html" >
      </frameset>
    </frameset>
  </html>
  
  
  
  1.1                  xml-site/targets/fop/design/alt.design/properties/introduction.html
  
  Index: introduction.html
  ===================================================================
  <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
  <html>
    <head>
      <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
      <title>Implementing Properties</title>
      <link type="text/css" href="../../../page.css" rel="stylesheet">
    </head>
    <body marginheight="0" marginwidth="0" topmargin="0" leftmargin="0" text="#000000" bgcolor="#FFFFFF">
      <div class="content">
        <h1>Implementing Properties</h1>
        <p>
          <font size="-2">by&nbsp;Peter B. West</font>
        </p>
        <ul class="minitoc">
          <li>
            <a href="#N10014">An alternative properties implementation</a>
            <ul class="minitoc">
              <li>
                <a href="#N10043">The history problem</a>
              </li>
              <li>
                <a href="#N10061">The construction hierarchy</a>
              </li>
              <li>
                <a href="#N10082">Representing properties: &lt;property&gt; classes</a>
              </li>
            </ul>
          </li>
        </ul>
        
        <a name="N10014"></a>
        <h3>An alternative properties implementation</h3>
        <div class="frame note">
          <div class="label">Note</div>
          <div class="content"> 
            The following discussion focusses on the relationship between
            Flow Objects in the Flow Object tree, and properties.  There
            is no (or only passing) discussion of the relationship between
            properties and traits, and by extension, between properties
            and the Area tree.
          </div>
        </div>
        <p>
          Property handling is complex and expensive. Varying numbers of
          properties <strong>apply</strong> to individual Flow Objects
          <strong>(FOs)</strong> in the <strong>FO tree </strong> but
          any property may effectively be assigned a value on any
          element of the tree.  If that property is inheritable, its
          defined value will then be available to any children of the
          defining FO.
        </p>
        <div class="frame note">
          <div class="label">Note</div>
          <div class="content">
            
            <em>(XSL 1.0 Rec)</em> <strong>5.1.4 Inheritance</strong>
            ...The inheritable properties can be placed on any formatting
            object.
          </div>
        </div>
        <p>
          Even if the value is not inheritable, it may be accessed by
          its children through the <span class="codefrag">inherit</span>
          keyword or the <span class="codefrag">from-parent()</span>
          core function, and potentially by any of its descendents
          through the <span
          class="codefrag">from-nearest-specified-value()</span> core
          function.
        </p>
        <p>
          In addition to the assigned values of properties, almost every
          property has an <strong>initial value</strong> which is used
          when no value has been assigned.
        </p>
        <a name="N10043"></a>
        <h4>The history problem</h4>
        <p>
          The difficulty and expense of handling properties comes from
          this univeral inheritance possibility.  The list of properties
          which are assigned values on any particular <em>FO</em>
          element will not generally be large, but a current value is
          required for each property which applies to the <em>FO</em>
          being processed.
        </p>
        <p>
          The environment from which these values may be selected
          includes, for each <em>FO</em>, <strong>for each applicable
            property</strong>, the value assigned on this <em>FO</em>,
          the value which applied to the parent of this <em>FO</em>,
          the nearest value specified on an ancestor of this element,
          and the initial value of the property.
        </p>
        <a name="N10061"></a>
        <h4>The construction hierarchy</h4>
        <p>
          Properties are resoved in the <strong>FO tree</strong> in a
          strictly hierarchical manner.  Nodes are detected in the
          input in a <strong>pre-order</strong> traversal, and are
          built in the same order.  This imples that there are two
          phases, or states, of property resolution and construction.
          Any particular FO node is either in a state of constructing
          its own subtree, or in a stable state where the subtree
          construction is complete.  These states have differenct data
          requirements.
        </p>
        <dl>
          
          <dt>Subtree building</dt>
          
          <dd>
            In this state, all properties defined on this node, or any
            of its ancestors must be available to the subtree.  In
            effect, any property defined on this node must be
            available to its descendants, as all properties defined on
            any ancestor are available to this node.
          </dd>
          
          <dt>Stable: subtree building complete</dt>
          
          <dd>
            In this state, only the properties <strong>applicable to
              this node</strong> need be available.
          </dd>
          
        </dl>
        <a name="N10082"></a>
        <h4>Representing properties: &lt;property&gt; classes</h4>
        <a name="N10087"></a>
        <h4>Class vs instance</h4>
        <p>
          What information is required of property objects?
          More particularly, what information is particular to the
          property classes, and what to the instantiated
          objects?  The answer to this question depend largely on
          how the property objects are used in the context
          of layout and Area tree construction.  The approach taken
          in this implementation is that properties are simply flags
          on certain data values associated with FOs.  The semantics
          of these flags are determined within the layout engine.
        </p>
        <p>
          Certain constant information attaches to individual
          property classes.  This information is detailed in
          the descriptions of individual properties in <em>Section
            7</em> of the specification.  Such information is
          represented in <strong>class</strong> fields and data
          structures within the classes.
        </p>
        <p>
          The "instance" information content of a property
          is:
        </p>
        <ul>
          
          <li>
            explicitly, the <span class="codefrag">PropertyValue</span> datum of
            the property, and
          </li>
          
          <li>
            implicitly, the <strong>Flow Object</strong> to which
            the property is attached.
          </li>
          
        </ul>
        <p>
          Properties, then, serve essentially to link <em>FO
            instances</em> with <em>PropertyValue instances</em>,
          attaching certain invariant semantic markers to the
          PropertyValues in the process.  In this implementation,
          these functions can be realised entirely within the
          property <strong>classes</strong> themselves,
          without the need to instantiate any objects.  In practice,
          <strong>property singletons</strong> are
          instantiated to make access to some invariants simpler.
        </p>
        <p>
          
          <strong>Next:</strong> <a href= "classes-overview.html"
                                    >Property classes overview.</a>
          
        </p>
        
      </div>
      <table summary="footer" cellspacing="0" cellpadding="0" width="100%" height="20" border="0">
          <tr>
            <td colspan="2" height="1" bgcolor="#4C6C8F"><img height="1"
            width="1" alt="" src="../../../skin/images/spacer.gif"><a
            href="../../../skin/images/label.gif"></a><a
            href="../../../skin/images/page.gif"></a><a
            href="../../../skin/images/chapter.gif"></a><a
            href="../../../skin/images/chapter_open.gif"></a><a
            href="../../../skin/images/current.gif"></a><a
            href="../../..//favicon.ico"></a></td>
          </tr>
          <tr>
            <td colspan="2" bgcolor="#CFDCED" class="copyright"
            align="center"><font size="2" face="Arial, Helvetica,
            Sans-Serif">Copyright &copy; 1999-2002&nbsp;The Apache
            Software Foundation. All rights reserved.<script
            type="text/javascript" language="JavaScript"><!--
            document.write(" - "+"Last Published: " +
            document.lastModified); // --></script></font></td>
          </tr>
          <tr>
            <td align="left" bgcolor="#CFDCED" class="logos"></td><td
            align="right" bgcolor="#CFDCED" class="logos"></td>
          </tr>
      </table>
    </body>
  </html>
  
  
  
  1.1                  xml-site/targets/fop/design/alt.design/properties/PropertyConsts-class.html
  
  Index: PropertyConsts-class.html
  ===================================================================
  <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
  <html>
    <head>
      <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
      <title>PropertyConsts Description</title>
      <link type="text/css" href="../../../page.css" rel="stylesheet">
    </head>
    <body marginheight="0" marginwidth="0" topmargin="0" leftmargin="0"
          text="#000000" bgcolor="#FFFFFF">
      <div class="content">
        <h1>PropertyConsts Description</h1>
        <p>
          <font size="-2">by&nbsp;Peter B. West</font>
        </p>
        <ul class="minitoc">
          <li>
            <a href="#N10014">Introduction</a>
          </li>
        </ul>
        
        <a name="N10014"></a>
        <h3>Introduction</h3>
        <p>
          
          <a href="javascript:parent.displayCode(
             'PropertyConsts.html#PropertyConstsClass'
          )">This class</a>, and the singleton object which is <a
          href="javascript:parent.displayCode(
          'PropertyConsts.html#pconsts' )">generated by the static
          initializer</a>, is essentially a repository of
          &lt;property&gt; class instances and the static data from
          those classes of <span
          class="codefrag">org.apache.fop.fo.property</span>.
          The heart of this class is the method <a href=
          "javascript:parent.displayCode(
          'PropertyConsts.html#setupProperty' )"><span class="codefrag"
          >setupProperty</span ></a>.  Whenever access to the data or
          methods of a property class is required, this method in the
          singleton must be called to ensure that an instance of the
          property exists and that the static data from that instance
          has been extracted.
        </p>
  
        <div class="frame note">
          <div class="label">Note</div>
          <div class="content">
            An alternative to this requirement would be to pre-load all
            of the individual property classes during the system
            initialization phase.  This is not done currently because of
            the start-up expense of the required class loading for over
            three hundred classes, and the relatively low added expense
            of checking for the existence of a property instance before
            every access.  Given that FOP is increasingly used in a
            server environment, it may prove acceptable in the long run
            to change to pre-loading.
          </div>
        </div>
  
        <p>
          The class name is generated and stored in the <a
          href="javascript:parent.displayCode(
          'PropertyConsts.html#classNames' )"><span class="codefrag"
          >classNames</span ></a> array; a class instance is generated
          from the name and stored in the <a
          href="javascript:parent.displayCode(
          'PropertyConsts.html#classes' )"><span class="codefrag"
          >classes</span ></a> array; and an instance of the class is
          generated from the class object and stored in the <a
          href="javascript:parent.displayCode(
          'PropertyConsts.html#properties' )"><span class="codefrag"
          >properties</span ></a> array.
        </p>
  
        <p>
          The other data gathering facilities and access methods of this
          class will be examined in conjunction with the various types
          of property classes.
        </p>
  
        <p>
          <strong>Previous:</strong> <a href = "classes-overview.html"
          >Property classes overview</a>
        </p>
        <p>
          <strong>Next:</strong> <a href= "simple-properties.html"
                                    >Simple property classes</a>
        </p>
      </div>
      <table summary="footer" cellspacing="0" cellpadding="0"
             width="100%" height="20" border="0">
          <tr>
            <td colspan="2" height="1" bgcolor="#4C6C8F"><img height="1" width="1" alt="" src="../../skin/images/spacer.gif"><a href="../../skin/images/label.gif"></a><a href="../../skin/images/page.gif"></a><a href="../../skin/images/chapter.gif"></a><a href="../../skin/images/chapter_open.gif"></a><a href="../../skin/images/current.gif"></a><a href="../..//favicon.ico"></a></td>
          </tr>
          <tr>
            <td colspan="2" bgcolor="#CFDCED" class="copyright" align="center"><font size="2" face="Arial, Helvetica, Sans-Serif">Copyright &copy;
                1999-2002&nbsp;The Apache Software Foundation. All rights reserved.<script type="text/javascript" language="JavaScript"><!--
                  document.write(" - "+"Last Published: " + document.lastModified);
                  //  --></script></font></td>
          </tr>
          <tr>
            <td align="left" bgcolor="#CFDCED" class="logos"></td><td align="right" bgcolor="#CFDCED" class="logos"></td>
          </tr>
      </table>
    </body>
  </html>
  
  
  
  1.1                  xml-site/targets/fop/design/alt.design/properties/PropertyConsts.html
  
  Index: PropertyConsts.html
  ===================================================================
  <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN">
  <!-- Created by htmlize-0.67 in css mode. -->
  <html>
    <head>
      <title>PropertyConsts.java</title>
      <style type="text/css">
      <!--
        body {
          color: #000000;
          background-color: #faf0e6;
        } /* default */
        .jde-java-font-lock-code {
          background-color: #faf0e6;
        } /* jde-java-font-lock-code-face */
        .function-name {
          color: #8b2323;
          background-color: #faf0e6;
        } /* font-lock-function-name-face */
        .jde-java-font-lock-italic {
          background-color: #faf0e6;
          font-style: italic;
        } /* jde-java-font-lock-italic-face */
        .jde-java-font-lock-modifier {
          color: #da70d6;
          background-color: #faf0e6;
        } /* jde-java-font-lock-modifier-face */
        .keyword {
          color: #8b0000;
          background-color: #faf0e6;
        } /* font-lock-keyword-face */
        .jde-java-font-lock-link {
          color: #0000ff;
          background-color: #faf0e6;
          text-decoration: underline;
        } /* jde-java-font-lock-link-face */
        .variable-name {
          color: #8b008b;
          background-color: #faf0e6;
        } /* font-lock-variable-name-face */
        .string {
          color: #008b00;
          background-color: #faf0e6;
        } /* font-lock-string-face */
        .jde-java-font-lock-package {
          color: #0000cd;
          background-color: #faf0e6;
        } /* jde-java-font-lock-package-face */
        .jde-java-font-lock-constant {
          color: #5f9ea0;
          background-color: #faf0e6;
        } /* jde-java-font-lock-constant-face */
        .type {
          color: #4682b4;
          background-color: #faf0e6;
        } /* font-lock-type-face */
        .jde-java-font-lock-bold {
          background-color: #faf0e6;
          font-weight: bold;
        } /* jde-java-font-lock-bold-face */
        .jde-java-font-lock-doc-tag {
          color: #008b00;
          background-color: #faf0e6;
        } /* jde-java-font-lock-doc-tag-face */
        .comment {
          color: #00008b;
          background-color: #faf0e6;
        } /* font-lock-comment-face */
        .jde-java-font-lock-number {
          color: #bc8f8f;
          background-color: #faf0e6;
        } /* jde-java-font-lock-number-face */
        a {
          color: inherit;
          background-color: inherit;
          font: inherit;
          text-decoration: inherit;
        }
        a:hover {
          text-decoration: underline;
        }
      -->
      </style>
    </head>
    <body>
      <pre>
  <span class="comment">/**
   * $Id: PropertyConsts.html,v 1.1 2003/01/24 10:46:48 pbwest Exp $
   * &lt;br/&gt;Copyright (C) 2001 The Apache Software Foundation. All rights reserved.
   * &lt;br/&gt;For details on use and redistribution please refer to the
   * &lt;br/&gt;LICENSE file included with these sources.
   *
   * </span><span class="jde-java-font-lock-doc-tag">@author</span><span class="comment"> &lt;a href=&quot;mailto:pbwest@powerup.com.au&quot;&gt;</span><span class="jde-java-font-lock-link">Peter B. West</span><span class="comment">&lt;/a&gt;
   * </span><span class="jde-java-font-lock-doc-tag">@version</span><span class="comment"> $Revision: 1.1 $ $Name:  $
   */</span>
  
  <span class="keyword">package</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>;
  
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">java</span>.<span class="jde-java-font-lock-package">lang</span>.<span class="type">Character</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">java</span>.<span class="jde-java-font-lock-package">lang</span>.<span class="jde-java-font-lock-package">reflect</span>.<span class="type">Method</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">java</span>.<span class="jde-java-font-lock-package">lang</span>.<span class="jde-java-font-lock-package">reflect</span>.<span class="type">InvocationTargetException</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">java</span>.<span class="jde-java-font-lock-package">util</span>.<span class="type">Arrays</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">java</span>.<span class="jde-java-font-lock-package">util</span>.<span class="type">Collections</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">java</span>.<span class="jde-java-font-lock-package">util</span>.<span class="type">HashMap</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">java</span>.<span class="jde-java-font-lock-package">util</span>.<span class="type">Map</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">java</span>.<span class="jde-java-font-lock-package">util</span>.<span class="type">List</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">java</span>.<span class="jde-java-font-lock-package">util</span>.<span class="type">HashSet</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">java</span>.<span class="jde-java-font-lock-package">util</span>.<span class="type">LinkedList</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">java</span>.<span class="jde-java-font-lock-package">util</span>.<span class="type">BitSet</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">java</span>.<span class="jde-java-font-lock-package">util</span>.<span class="type">StringTokenizer</span>;
  
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="type">FOTree</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="type">FONode</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="type">PropNames</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="jde-java-font-lock-package">properties</span>.<span class="type">Property</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="jde-java-font-lock-package">expr</span>.<span class="type">PropertyException</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">Numeric</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">Ints</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datastructs</span>.<span class="type">ROIntArray</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datastructs</span>.<span class="type">ROStringArray</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datastructs</span>.<span class="type">ROBitSet</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">PropertyValue</span>;
  
  <span class="comment">/**
   * This class contains a number of arrays containing values indexed by the
   * property index value, determined from the PropNames class.  These arrays
   * provide a means of accessing information about the nature of a property
   * through the property index value.
   * &lt;p&gt;Most of these arrays are initialised piecemeal as information is
   * required about a particular property.
   * There are also &lt;tt&gt;HashMap&lt;/tt&gt;s which encode the various sets of
   * properties which are defined to apply to each of the Flow Objects,
   * and a &lt;tt&gt;BitSet&lt;/tt&gt; of those properties which are
   * automatically inherited.  The &lt;tt&gt;HashMap&lt;/tt&gt;s provide a convenient
   * means of specifying the relationship between FOs and properties.
   */</span>
  <span class="jde-java-font-lock-modifier">public</span> <span class="keyword">class</span> <span class="function-name" id="PropertyConstsClass">PropertyConsts</span> {
  
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">String</span> <span class="variable-name" id="tag">tag</span> = &quot;<span class="string">$Name:  $</span>&quot;;
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">String</span> <span class="variable-name" id="revision">revision</span> = &quot;<span class="string">$Revision: 1.1 $</span>&quot;;
  
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">String</span> <span class="variable-name" id="packageName">packageName</span> = &quot;<span class="string">org.apache.fop.fo</span>&quot;;
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">PropertyConsts</span> <span class="variable-name" id="pconsts">pconsts</span>;
      <span class="jde-java-font-lock-modifier">static</span> {
          <span class="keyword">try</span> {
              pconsts = <span class="keyword">new</span> <span class="type">PropertyConsts</span>();
          } <span class="keyword">catch</span> (<span class="type">PropertyException</span> <span class="variable-name" id="e">e</span>) {
              <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">RuntimeException</span>(e.getMessage());
          }
      }
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">PropertyConsts</span> <span class="function-name" id="getPropertyConsts">getPropertyConsts</span>() {
          <span class="keyword">return</span> pconsts;
      }
  
  
      <span class="comment">/**
       * A Property[] array containing Property objects corresponding to each
       * of the property indices in &lt;tt&gt;PropNames&lt;/tt&gt;.
       * Initially empty, entries are filled on demand as calls for details
       * about individual properties are made.
       */</span>
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">Property</span>[] <span class="variable-name" id="properties">properties</span>
                          = <span class="keyword">new</span> <span class="type">Property</span>[PropNames.<span class="jde-java-font-lock-constant" id="LAST_PROPERTY_INDEX">LAST_PROPERTY_INDEX</span> + <span class="jde-java-font-lock-number">1</span>];
  
      <span class="comment">/**
       * A Class[] array containing Class objects corresponding to each of the
       * class names in the classNames array.  Elements are set
       * in parallel to the creation of the class names in
       * the classNames array.  It can be indexed by the property name
       * constants defined in this file.
       */</span>
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">Class</span>[] <span class="variable-name" id="classes">classes</span>
                              = <span class="keyword">new</span> <span class="type">Class</span>[PropNames.<span class="jde-java-font-lock-constant">LAST_PROPERTY_INDEX</span> + <span class="jde-java-font-lock-number">1</span>];
  
      <span class="comment">/**
       * A String[] array of the property class names.  This array is
       * effectively 1-based, with the first element being unused.
       * The elements of this array are set by converting the FO
       * property names from the array PropNames.propertyNames into class
       * names by converting the first character of every component word to
       * upper case, and removing all punctuation characters.
       * It can be indexed by the property name constants defined in
       * the PropNames class.
       */</span>
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">String</span>[] <span class="variable-name" id="classNames">classNames</span>
                              = <span class="keyword">new</span> <span class="type">String</span>[PropNames.<span class="jde-java-font-lock-constant">LAST_PROPERTY_INDEX</span> + <span class="jde-java-font-lock-number">1</span>];
  
      <span class="comment">/**
       * A HashMap whose elements are an integer index value keyed by the name
       * of a property class.  The index value is the index of the property
       * class name in the classNames[] array.
       */</span>
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">HashMap</span> <span class="variable-name" id="classToIndex">classToIndex</span>
                          = <span class="keyword">new</span> <span class="type">HashMap</span>(PropNames.<span class="jde-java-font-lock-constant">LAST_PROPERTY_INDEX</span> + <span class="jde-java-font-lock-number">1</span>);
  
      <span class="comment">/**
       * An &lt;tt&gt;int[]&lt;/tt&gt; containing the &lt;i&gt;</span><span class="jde-java-font-lock-italic">inherited</span><span class="comment">&lt;/i&gt; values from the
       * &lt;tt&gt;Property&lt;/tt&gt; classes.
       */</span>
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span>[] <span class="variable-name" id="inherited">inherited</span>
                              = <span class="keyword">new</span> <span class="type">int</span>[PropNames.<span class="jde-java-font-lock-constant">LAST_PROPERTY_INDEX</span> + <span class="jde-java-font-lock-number">1</span>];
  
      <span class="comment">/**
       * A &lt;tt&gt;BitSet&lt;/tt&gt; of properties which are normally inherited
       * (strictly, not not inherited).
       * It is defined relative to the set of all properties; i.e. the
       * inheritability of any property can be established by testing the
       * bit in this set that corresponds to the queried property's index.
       * &lt;p&gt;The &lt;tt&gt;BitSet&lt;/tt&gt; is private and is the basis for
       * &lt;i&gt;</span><span class="jde-java-font-lock-italic">inheritedProperties</span><span class="comment">&lt;/i&gt;.
       */</span>
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">BitSet</span> <span class="variable-name" id="inheritedprops">inheritedprops</span>
                              = <span class="keyword">new</span> <span class="type">BitSet</span>(PropNames.<span class="jde-java-font-lock-constant">LAST_PROPERTY_INDEX</span> + <span class="jde-java-font-lock-number">1</span>);
  
      <span class="comment">/**
       * An int[] array of the types of the &lt;i&gt;</span><span class="jde-java-font-lock-italic">initialValue</span><span class="comment">&lt;/i&gt; field of each
       * property.  The array is indexed by the index value constants that are
       * defined in the PropNames class in parallel to the
       * PropNames.propertyNames[] array.
       */</span>
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span>[] <span class="variable-name" id="initialValueTypes">initialValueTypes</span>
                              = <span class="keyword">new</span> <span class="type">int</span>[PropNames.<span class="jde-java-font-lock-constant">LAST_PROPERTY_INDEX</span> + <span class="jde-java-font-lock-number">1</span>];
  
      <span class="comment">/**
       * A &lt;tt&gt;PropertyValue&lt;/tt&gt; array containing the initial values of
       * each of the properties.
       */</span>
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">PropertyValue</span>[] <span class="variable-name" id="initialValues">initialValues</span>
                      = <span class="keyword">new</span> <span class="type">PropertyValue</span>[PropNames.<span class="jde-java-font-lock-constant">LAST_PROPERTY_INDEX</span> + <span class="jde-java-font-lock-number">1</span>];
  
      <span class="comment">/**
       * An int[] array of the values of the &lt;i&gt;</span><span class="jde-java-font-lock-italic">dataTypes</span><span class="comment">&lt;/i&gt; field of each
       * property.  The array is indexed by the index value constants that are
       * defined in the PropNames class in parallel to the
       * PropNames.propertyNames[] array.
       * The array elements are set from the values of the
       * &lt;i&gt;</span><span class="jde-java-font-lock-italic">dataTypes</span><span class="comment">&lt;/i&gt; field in each property class.
       */</span>
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span>[] <span class="variable-name" id="datatypes">datatypes</span>
                              = <span class="keyword">new</span> <span class="type">int</span>[PropNames.<span class="jde-java-font-lock-constant">LAST_PROPERTY_INDEX</span> + <span class="jde-java-font-lock-number">1</span>];
  
      <span class="comment">/**
       * An int[] array of the values of the &lt;i&gt;</span><span class="jde-java-font-lock-italic">traitMapping</span><span class="comment">&lt;/i&gt; field of each
       * property.  The array is indexed by the index value constants that are
       * defined in the PropNames class in parallel to the
       * PropNames.propertyNames[] array.
       * The array elements are set from the values of the
       * &lt;i&gt;</span><span class="jde-java-font-lock-italic">traitMapping</span><span class="comment">&lt;/i&gt; field in each property class.
       */</span>
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span>[] <span class="variable-name" id="traitMappings">traitMappings</span>
                              = <span class="keyword">new</span> <span class="type">int</span>[PropNames.<span class="jde-java-font-lock-constant">LAST_PROPERTY_INDEX</span> + <span class="jde-java-font-lock-number">1</span>];
  
      <span class="comment">/**
       * Get the initial value type for a property name.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="property">property</span><span class="comment"> String name of the FO property
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> int enumerated initialValueType.  These constants are defined
       * as static final ints in this class.  Note that an undefined property
       * name will return the constant defined as NOTYPE_IT
       */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">int</span> <span class="function-name" id="getInitialValueType">getInitialValueType</span>(<span class="type">String</span> <span class="variable-name">property</span>)
                      <span class="keyword">throws</span> <span class="type">PropertyException</span>
      {
          <span class="comment">// Get the property index then index into the initialvaluetypes array
  </span>        <span class="keyword">return</span> getInitialValueType(PropNames.getPropertyIndex(property));
      }
  
      <span class="comment">/**
       * get the initial value type for a property index.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="propindex">propindex</span><span class="comment"> int index of the FO property
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> int enumerated initialValueType.  These constants are defined
       * as static final ints in the Property class.
       * </span><span class="jde-java-font-lock-doc-tag">@throws</span><span class="comment"> </span><span class="type">PropertyException
  </span><span class="comment">     */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">int</span> <span class="function-name">getInitialValueType</span>(<span class="type">int</span> <span class="variable-name">propindex</span>)
              <span class="keyword">throws</span> <span class="type">PropertyException</span>
      {
          setupProperty(propindex);
          <span class="comment">//System.out.println(&quot;getInitialValueType: &quot; + propindex + &quot; &quot;
  </span>                            <span class="comment">//+ initialValueTypes[propindex]);
  </span>        <span class="keyword">return</span> initialValueTypes[propindex];
      }
  
      <span class="comment">/**
       * Get the initial value &lt;tt&gt;PropertyValue&lt;/tt&gt; for a given property.
       * Note that this is a &lt;b&gt;</span><span class="jde-java-font-lock-bold">raw</span><span class="comment">&lt;/b&gt; value; if it is
       * an unresolved percentage that value will be returned.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="index">index</span><span class="comment"> - the property index.
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> a &lt;tt&gt;PropertyValue&lt;/tt&gt; containing the initial property
       * value element for the indexed property.
       * </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">&lt;tt&gt;PropertyException&lt;/tt&gt;
  </span><span class="comment">     */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">PropertyValue</span> <span class="function-name" id="getInitialValue">getInitialValue</span>(<span class="type">int</span> <span class="variable-name">propindex</span>)
              <span class="keyword">throws</span> <span class="type">PropertyException</span>
      {
          <span class="keyword">if</span> (initialValues[propindex] != <span class="jde-java-font-lock-constant" id="null">null</span>)
              <span class="keyword">return</span> initialValues[propindex];
          <span class="comment">//System.out.println(&quot;PropertyConts.getInitialValue(&quot; + propindex
  </span>                           <span class="comment">//+ &quot;) &quot; + PropNames.getPropertyName(propindex));
  </span>        <span class="keyword">return</span>
              (initialValues[propindex] =
                      setupProperty(propindex).getInitialValue(propindex));
      }
  
      <span class="comment">/**
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">propindex</span><span class="comment"> &lt;tt&gt;int&lt;/tt&gt; index of the property
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="foNode">foNode</span><span class="comment"> the node whose properties are being constructed.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="value">value</span><span class="comment"> the &lt;tt&gt;PropertyValue&lt;/tt&gt; being refined.
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> &lt;tt&gt;PropertyValue&lt;/tt&gt; constructed by the property's
       * &lt;i&gt;</span><span class="jde-java-font-lock-italic">refineParsing</span><span class="comment">&lt;/i&gt; method
       * </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">&lt;tt&gt;PropertyException&lt;/tt&gt;
  </span><span class="comment">     */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">PropertyValue</span> <span class="variable-name" id="refineParsing">refineParsing</span>
                          (<span class="type">int</span> <span class="variable-name">propindex</span>, <span class="type">FONode</span> <span class="variable-name">foNode</span>, <span class="type">PropertyValue</span> <span class="variable-name">value</span>)
          <span class="keyword">throws</span> <span class="type">PropertyException</span>
      {
          <span class="type">Property</span> <span class="variable-name">property</span> = setupProperty(propindex);
          <span class="keyword">return</span> property.refineParsing(propindex, foNode, value);
      }
  
      <span class="comment">/**
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">propindex</span><span class="comment"> &lt;tt&gt;int&lt;/tt&gt; index of the property
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">foNode</span><span class="comment"> the node whose properties are being constructed.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">value</span><span class="comment"> the &lt;tt&gt;PropertyValue&lt;/tt&gt; being refined.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="nested">nested</span><span class="comment"> - &lt;tt&gt;boolean&lt;/tt&gt; indicating whether this method is
       * called normally (false), or as part of another &lt;i&gt;</span><span class="jde-java-font-lock-italic">refineParsing</span><span class="comment">&lt;/i&gt;
       * method.
       * </span><span class="jde-java-font-lock-doc-tag">@see</span><span class="comment"> </span><span class="jde-java-font-lock-code">#refineParsing</span><span class="comment">(FOTree,PropertyValue)
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> &lt;tt&gt;PropertyValue&lt;/tt&gt; constructed by the property's
       * &lt;i&gt;</span><span class="jde-java-font-lock-italic">refineParsing</span><span class="comment">&lt;/i&gt; method
       * </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">&lt;tt&gt;PropertyException&lt;/tt&gt;
  </span><span class="comment">     */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">PropertyValue</span> <span class="variable-name">refineParsing</span>
          (<span class="type">int</span> <span class="variable-name">propindex</span>, <span class="type">FONode</span> <span class="variable-name">foNode</span>, <span class="type">PropertyValue</span> <span class="variable-name">value</span>, <span class="type">boolean</span> <span class="variable-name">isNested</span>)
          <span class="keyword">throws</span> <span class="type">PropertyException</span>
      {
          <span class="type">Property</span> <span class="variable-name">property</span> = setupProperty(propindex);
          <span class="keyword">return</span> property.refineParsing(propindex, foNode, value, isNested);
      }
  
      <span class="comment">/**
       * Get the &lt;tt&gt;Numeric&lt;/tt&gt; value corresponding to an enumerated value.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">foNode</span><span class="comment"> the &lt;tt&gt;FONode&lt;/tt&gt; being built
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">propindex</span><span class="comment"> int index of the FO property
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="enum">enum</span><span class="comment"> - the integer equivalent of the enumeration keyword.
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> the &lt;tt&gt;Numeric&lt;/tt&gt; result.
       * </span><span class="jde-java-font-lock-doc-tag">@throws</span><span class="comment"> </span><span class="type">PropertyException.
  </span><span class="comment">     */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">Numeric</span> <span class="function-name" id="getMappedNumeric">getMappedNumeric</span>(<span class="type">FONode</span> <span class="variable-name">foNode</span>, <span class="type">int</span> <span class="variable-name">propindex</span>, <span class="type">int</span> <span class="variable-name">enum</span>)
              <span class="keyword">throws</span> <span class="type">PropertyException</span>
      {
          <span class="type">Property</span> <span class="variable-name">property</span> = setupProperty(propindex);
          <span class="keyword">if</span> ((datatypes[propindex] &amp; Property.<span class="jde-java-font-lock-constant" id="MAPPED_LENGTH">MAPPED_LENGTH</span>) != <span class="jde-java-font-lock-number">0</span>)
              <span class="keyword">return</span> property.getMappedLength(foNode, enum);
          <span class="keyword">else</span>
              <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>
                  (&quot;<span class="string">MAPPED_LENGTH not valid in </span>&quot;
                                      + PropNames.getPropertyName(propindex));
      }
  
      <span class="comment">/**
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">propindex</span><span class="comment"> int index of the FO property
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> int type of inheritance for this property
       * (See constants defined in Properties.)
       * </span><span class="jde-java-font-lock-doc-tag">@throws</span><span class="comment"> </span><span class="type">PropertyException.
  </span><span class="comment">     */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">int</span> <span class="function-name" id="inheritance">inheritance</span>(<span class="type">String</span> <span class="variable-name">property</span>) <span class="keyword">throws</span> <span class="type">PropertyException</span> {
          <span class="keyword">return</span> inheritance(PropNames.getPropertyIndex(property));
      }
  
      <span class="comment">/**
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">propindex</span><span class="comment"> int index of the FO property
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> int type of inheritance for this property
       * (See constants defined in Property.)
       * </span><span class="jde-java-font-lock-doc-tag">@throws</span><span class="comment"> </span><span class="type">PropertyException.
  </span><span class="comment">     */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">int</span> <span class="function-name">inheritance</span>(<span class="type">int</span> <span class="variable-name">propindex</span>) <span class="keyword">throws</span> <span class="type">PropertyException</span> {
          setupProperty(propindex);
          <span class="keyword">return</span> inherited[propindex];
      }
  
      <span class="comment">/**
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">propindex</span><span class="comment"> int index of the FO property
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> &lt;tt&gt;boolean&lt;/tt&gt; is property inherited?
       * </span><span class="jde-java-font-lock-doc-tag">@throws</span><span class="comment"> </span><span class="type">PropertyException.
  </span><span class="comment">     */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">boolean</span> <span class="function-name" id="isInherited">isInherited</span>(<span class="type">int</span> <span class="variable-name">propindex</span>) <span class="keyword">throws</span> <span class="type">PropertyException</span> {
          <span class="type">Property</span> <span class="variable-name">property</span> = setupProperty(propindex);
          <span class="keyword">return</span> inherited[propindex] != Property.<span class="jde-java-font-lock-constant" id="NO">NO</span>;
      }
  
      <span class="comment">/**
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">property</span><span class="comment"> String name of the FO property
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> &lt;tt&gt;boolean&lt;/tt&gt; is property inherited?
       * </span><span class="jde-java-font-lock-doc-tag">@throws</span><span class="comment"> </span><span class="type">PropertyException.
  </span><span class="comment">     */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">boolean</span> <span class="function-name">isInherited</span>(<span class="type">String</span> <span class="variable-name">property</span>) <span class="keyword">throws</span> <span class="type">PropertyException</span> {
          <span class="keyword">return</span> isInherited(PropNames.getPropertyIndex(property));
      }
  
      <span class="comment">/**
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">propindex</span><span class="comment"> int index of the FO property
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> &lt;tt&gt;boolean&lt;/tt&gt; is property a shorthand?
       * </span><span class="jde-java-font-lock-doc-tag">@throws</span><span class="comment"> </span><span class="type">PropertyException.
  </span><span class="comment">     */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">boolean</span> <span class="function-name" id="isShorthand">isShorthand</span>(<span class="type">int</span> <span class="variable-name">propindex</span>) <span class="keyword">throws</span> <span class="type">PropertyException</span> {
          <span class="type">Property</span> <span class="variable-name">property</span> = setupProperty(propindex);
          <span class="keyword">return</span> (datatypes[propindex] &amp; Property.<span class="jde-java-font-lock-constant" id="SHORTHAND">SHORTHAND</span>) != <span class="jde-java-font-lock-number">0</span>;
      }
  
      <span class="comment">/**
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">property</span><span class="comment"> String name of the FO property
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> &lt;tt&gt;boolean&lt;/tt&gt; is property a shorthand?
       * </span><span class="jde-java-font-lock-doc-tag">@throws</span><span class="comment"> </span><span class="type">PropertyException.
  </span><span class="comment">     */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">boolean</span> <span class="function-name">isShorthand</span>(<span class="type">String</span> <span class="variable-name">property</span>) <span class="keyword">throws</span> <span class="type">PropertyException</span> {
          <span class="keyword">return</span> isShorthand(PropNames.getPropertyIndex(property));
      }
  
      <span class="comment">/**
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="propertyIndex">propertyIndex</span><span class="comment"> int index of the FO property
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> &lt;tt&gt;boolean&lt;/tt&gt; is property a compound?
       * </span><span class="jde-java-font-lock-doc-tag">@throws</span><span class="comment"> </span><span class="type">PropertyException.
  </span><span class="comment">     */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">boolean</span> <span class="function-name" id="isCompound">isCompound</span>(<span class="type">int</span> <span class="variable-name">propertyIndex</span>) <span class="keyword">throws</span> <span class="type">PropertyException</span> {
          <span class="type">Property</span> <span class="variable-name">property</span> = setupProperty(propertyIndex);
          <span class="keyword">return</span> (datatypes[propertyIndex] &amp; Property.<span class="jde-java-font-lock-constant" id="COMPOUND">COMPOUND</span>) != <span class="jde-java-font-lock-number">0</span>;
      }
  
      <span class="comment">/**
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">property</span><span class="comment"> String name of the FO property
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> &lt;tt&gt;boolean&lt;/tt&gt; is property a compound?
       * </span><span class="jde-java-font-lock-doc-tag">@throws</span><span class="comment"> </span><span class="type">PropertyException.
  </span><span class="comment">     */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">boolean</span> <span class="function-name">isCompound</span>(<span class="type">String</span> <span class="variable-name">property</span>) <span class="keyword">throws</span> <span class="type">PropertyException</span> {
          <span class="keyword">return</span> isCompound(PropNames.getPropertyIndex(property));
      }
  
      <span class="comment">/**
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">propertyIndex</span><span class="comment"> int index of the FO property
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> &lt;tt&gt;int&lt;/tt&gt; dataTypes value.
       * </span><span class="jde-java-font-lock-doc-tag">@throws</span><span class="comment"> </span><span class="type">PropertyException.
  </span><span class="comment">     */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">int</span> <span class="function-name" id="getDataTypes">getDataTypes</span>(<span class="type">int</span> <span class="variable-name">propertyIndex</span>) <span class="keyword">throws</span> <span class="type">PropertyException</span> {
          <span class="type">Property</span> <span class="variable-name">property</span> = setupProperty(propertyIndex);
          <span class="keyword">return</span> datatypes[propertyIndex];
      }
  
      <span class="comment">/**
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">property</span><span class="comment"> String name of the FO property
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> &lt;tt&gt;int&lt;/tt&gt; dataTypes value.
       * </span><span class="jde-java-font-lock-doc-tag">@throws</span><span class="comment"> </span><span class="type">PropertyException.
  </span><span class="comment">     */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">int</span> <span class="function-name">getDataTypes</span>(<span class="type">String</span> <span class="variable-name">property</span>) <span class="keyword">throws</span> <span class="type">PropertyException</span> {
          <span class="keyword">return</span> getDataTypes(PropNames.getPropertyIndex(property));
      }
  
      <span class="comment">/**
       * Map the integer value of an enum into its mapped value.
       * Only valid when the datatype of the property includes MAPPED_ENUM.
       * &lt;p&gt;Generally, the path will be enumText-&gt;enumIndex-&gt;mappedEnumText.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">index</span><span class="comment"> &lt;tt&gt;int&lt;/tt&gt; containing the enumeration index.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="enumMap">enumMap</span><span class="comment"> an &lt;tt&gt;ROStringArray&lt;/tt&gt; of the &lt;tt&gt;String&lt;/tt&gt;s 
       * with the mapped enumeration values.
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> a &lt;tt&gt;String&lt;/tt&gt; with the mapped enumeration text.
       */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">String</span> <span class="function-name" id="enumIndexToMapping">enumIndexToMapping</span>(<span class="type">int</span> <span class="variable-name">index</span>, <span class="type">ROStringArray</span> <span class="variable-name">enumMap</span>)
      {
          <span class="keyword">return</span> enumMap.get(index);
      }
  
      <span class="comment">/**
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">propindex</span><span class="comment"> &lt;tt&gt;int&lt;/tt&gt; property index.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">enum</span><span class="comment"> &lt;tt&gt;String&lt;/tt&gt; containing the enumeration text.
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> &lt;tt&gt;int&lt;/tt&gt; constant representing the enumeration value.
       * </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">PropertyException
  </span><span class="comment">     */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">int</span> <span class="function-name" id="getEnumIndex">getEnumIndex</span>(<span class="type">int</span> <span class="variable-name">propindex</span>, <span class="type">String</span> <span class="variable-name">enum</span>)
                      <span class="keyword">throws</span> <span class="type">PropertyException</span>
      {
          <span class="type">Property</span> <span class="variable-name">property</span> = setupProperty(propindex);
          <span class="keyword">return</span> property.getEnumIndex(enum);
      }
  
      <span class="comment">/**
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">propindex</span><span class="comment"> &lt;tt&gt;int&lt;/tt&gt; property index.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="enumIndex">enumIndex</span><span class="comment"> &lt;tt&gt;int&lt;/tt&gt; containing the enumeration index.
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> &lt;tt&gt;String&lt;/tt&gt; containing the enumeration text.
       * </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">PropertyException
  </span><span class="comment">     */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">String</span> <span class="function-name" id="getEnumText">getEnumText</span>(<span class="type">int</span> <span class="variable-name">propindex</span>, <span class="type">int</span> <span class="variable-name">enumIndex</span>)
                      <span class="keyword">throws</span> <span class="type">PropertyException</span>
      {
          <span class="type">Property</span> <span class="variable-name">property</span> = setupProperty(propindex);
          <span class="keyword">return</span> property.getEnumText(enumIndex);
      }
  
      <span class="comment">/**
       * Set up the details of a single property and return the
       * &lt;tt&gt;Property&lt;/tt&gt; object.  If the &lt;tt&gt;Property&lt;/tt&gt; object
       * corresponding to the property index has not been resolved before,
       * derive the Class and Property objects, and extract certain field
       * values from the Property.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">propindex</span><span class="comment"> - the &lt;tt&gt;int&lt;/tt&gt; index.
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> - the &lt;tt&gt;Property&lt;/tt&gt; corresponding to the index.
       * </span><span class="jde-java-font-lock-doc-tag">@throws</span><span class="comment"> </span><span class="type">&lt;tt&gt;PropertyException.
  </span><span class="comment">     */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">Property</span> <span class="function-name" id="setupProperty">setupProperty</span>(<span class="type">int</span> <span class="variable-name">propindex</span>)
              <span class="keyword">throws</span> <span class="type">PropertyException</span>
      {
          <span class="type">String</span> <span class="variable-name" id="cname">cname</span> = &quot;&quot;;
          <span class="type">Class</span> <span class="variable-name" id="pclass">pclass</span>;
          <span class="type">Property</span> <span class="variable-name">property</span>;
  
          <span class="comment">//System.out.println(&quot;setupProperty &quot; + propindex + &quot; &quot;
  </span>                            <span class="comment">//+ PropNames.getPropertyName(propindex));
  </span>        <span class="keyword">if</span> ((property = properties[propindex]) != <span class="jde-java-font-lock-constant">null</span>) <span class="keyword">return</span> property;
  
          <span class="comment">// Get the property class name
  </span>        <span class="type">StringTokenizer</span> <span class="variable-name" id="stoke">stoke</span>;
          stoke = <span class="keyword">new</span> <span class="type">StringTokenizer</span>
                              (PropNames.getPropertyName(propindex), &quot;<span class="string">-.:</span>&quot;);
          <span class="keyword">while</span> (stoke.hasMoreTokens()) {
              <span class="type">String</span> <span class="variable-name" id="token">token</span> = stoke.nextToken();
              <span class="type">String</span> <span class="variable-name" id="pname">pname</span> = <span class="keyword">new</span> <span class="type">Character</span>(
                                  Character.toUpperCase(token.charAt(<span class="jde-java-font-lock-number">0</span>))
                              ).toString() + token.substring(<span class="jde-java-font-lock-number">1</span>);
              cname = cname + pname;
          }
          classNames[propindex] = cname;
          
          <span class="comment">// Set up the classToIndex Hashmap with the name of the
  </span>        <span class="comment">// property class as a key, and the integer index as a value
  </span>        <span class="keyword">if</span> (classToIndex.put(cname, Ints.consts.get(propindex)) != <span class="jde-java-font-lock-constant">null</span>)
              <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>
                  (&quot;<span class="string">Duplicate values in classToIndex for key </span>&quot; + cname);
  
          <span class="comment">// Get the class for this property name
  </span>        <span class="type">String</span> <span class="variable-name" id="name">name</span> = packageName + &quot;<span class="string">.properties.</span>&quot; + cname;
          <span class="keyword">try</span> {
              <span class="comment">//System.out.println(&quot;classes[&quot;+propindex+&quot;] &quot;+name);//DEBUG
  </span>            pclass = Class.forName(name);
              classes[propindex] = pclass;
  
              <span class="comment">// Instantiate the class
  </span>            property = (<span class="type">Property</span>)(pclass.newInstance());
              properties[propindex] = property;
              <span class="comment">//System.out.println
  </span>                    <span class="comment">//(&quot;property name &quot;
  </span>                     <span class="comment">//+ property.getClass().getName());
  </span>            <span class="comment">//System.out.println
  </span>            <span class="comment">//(&quot;property name &quot; +
  </span>            <span class="comment">//properties[propindex].getClass().getName());
  </span>
              <span class="comment">// Set inheritance value
  </span>            <span class="keyword">if</span> ((inherited[propindex]
                                  = pclass.getField(&quot;<span class="string">inherited</span>&quot;).getInt(<span class="jde-java-font-lock-constant">null</span>))
                      != Property.<span class="jde-java-font-lock-constant">NO</span>)
                              inheritedprops.set(propindex);
              <span class="comment">// Set datatypes
  </span>            datatypes[propindex] = pclass.getField(&quot;<span class="string">dataTypes</span>&quot;).getInt(<span class="jde-java-font-lock-constant">null</span>);
              <span class="comment">//System.out.println(&quot;datatypes &quot; + datatypes[propindex] + &quot;\n&quot;
  </span>                           <span class="comment">//+ Property.listDataTypes(datatypes[propindex]));
  </span>
              <span class="comment">// Set initialValueTypes
  </span>            initialValueTypes[propindex] =
                              pclass.getField(&quot;<span class="string">initialValueType</span>&quot;).getInt(<span class="jde-java-font-lock-constant">null</span>);
              <span class="comment">//System.out.println(&quot;initialValueType &quot;
  </span>                               <span class="comment">//+ initialValueTypes[propindex]);
  </span>
              traitMappings[propindex] =
                                  pclass.getField(&quot;<span class="string">traitMapping</span>&quot;).getInt(<span class="jde-java-font-lock-constant">null</span>);
  
          } <span class="keyword">catch</span> (<span class="type">ClassNotFoundException</span> <span class="variable-name">e</span>) {
              <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>
                      (&quot;<span class="string">ClassNotFoundException</span>&quot; + e.getMessage());
          } <span class="keyword">catch</span> (<span class="type">IllegalAccessException</span> <span class="variable-name">e</span>) {
              <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>
                      (&quot;<span class="string">IllegalAccessException</span>&quot; + e.getMessage());
          } <span class="keyword">catch</span> (<span class="type">InstantiationException</span> <span class="variable-name">e</span>) {
              <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>
                      (&quot;<span class="string">InstantiationException</span>&quot; + e.getMessage());
          }
          <span class="keyword">catch</span> (<span class="type">NoSuchFieldException</span> <span class="variable-name">e</span>) {
              <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>
                      (&quot;<span class="string">NoSuchFieldException</span>&quot; + e.getMessage());
          }
  
          <span class="keyword">return</span> property;
      }
  
  
      <span class="jde-java-font-lock-modifier">private</span> <span class="function-name" id="PropertyConsts">PropertyConsts</span> () <span class="keyword">throws</span> <span class="type">PropertyException</span> {}
  
  }
  </pre>
    </body>
  </html>
  
  
  
  1.1                  xml-site/targets/fop/design/alt.design/properties/propertyExpressions.html
  
  Index: propertyExpressions.html
  ===================================================================
  <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
  <html>
    <head>
      <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
      <title>Property Expression Parsing</title>
      <link type="text/css" href="../../../page.css" rel="stylesheet">
    </head>
    <body marginheight="0" marginwidth="0" topmargin="0" leftmargin="0" text="#000000" bgcolor="#FFFFFF">
      <div class="content">
        <h1>Property Expression Parsing</h1>
        <p>
          <font size="-2">by&nbsp;Peter B. West</font>
        </p>
        <ul class="minitoc">
          <li>
            <a href="#N10014">Property expression parsing</a>
            <ul class="minitoc">
              <li>
                <a href="#N10044">Data types</a>
              </li>
              <li>
                <a href="#N10252">Tokenizer</a>
              </li>
              <li>
                <a href="#N1029C">Parser</a>
              </li>
            </ul>
          </li>
        </ul>
        
        <a name="N10014"></a>
        <h3>Property expression parsing</h3>
        <p>
          The parsing of property value expressions is handled by two
          closely related classes: <a href=
          "javascript:parent.displayCode(
          'PropertyTokenizer.html#PropertyTokenizerClass' )" ><span
          class= "codefrag" >org.apache.fop.fo.expr.PropertyTokenizer</span></a>
          and its subclass, <a href= "javascript:parent.displayCode(
          'PropertyParser.html#PropertyParserClass' )" ><span
          class= "codefrag" >org.apache.fop.fo.expr.PropertyParser</span></a>,
          and by <span class= "codefrag" >refineParsing(int, FONode,
          PropertyValue)</span> methods in the individual property
          classes.  <span class= "codefrag" >PropertyTokenizer</span>, as
          the name suggests, handles the tokenizing of the expression,
          handing <a href= "javascript:parent.displayCode(
          'PropertyTokenizer.html#EOF' )" ><em>tokens</em></a> back to
          its subclass, <span
          class= "codefrag" >PropertyParser</span>. <span
          class= "codefrag" >PropertyParser</span>, in turn, returns a <a
          href= "javascript:parent.displayCode(
          'PropertyValueList.html#PropertyValueListClass' )" ><span
          class= "codefrag">PropertyValueList</span></a>, a list of <a
          href= "javascript:parent.displayCode(
          'PropertyValue.html#PropertyValueInterface' )" ><span class=
          "codefrag">PropertyValue</span></a>s.
        </p>
        <p>
          The tokenizer and parser rely in turn on the datatype
          definitions from the <span
          class= "codefrag" >org.apache.fop.datatypes</span> package,
          which include the <a href= "javascript:parent.displayCode(
          'PropertyValue.html#NO_TYPE' )" ><span class= "codefrag"
          >PropertyValue</span> datatype constant definitions</a>.
        </p>
        <a name="N10044"></a>
        <h4>Data types</h4>
        <p>
          The data types currently defined in
          <span class= "codefrag" >org.apache.fop.datatypes</span> include:
        </p>
        <table class="ForrestTable" cellspacing="1" cellpadding="4">
          
            <tr>
              <th colspan="2" rowspan="1">Numbers and lengths</th>
            </tr>
            
            <tr>
              <th colspan="1" rowspan="1">Numeric</th>
              <td colspan="3" rowspan="1">
                The fundamental length data type.  <em>Numerics</em> of
                various types are constructed by the classes listed
                below.
              </td>
            </tr>
            
            <tr>
              <td colspan="1" rowspan="1"></td>
              <th colspan="3"
                  rowspan="1">Constructor classes for <em>Numeric</em></th>
            </tr>
            
            <tr>
              <td colspan="1" rowspan="1"></td>
              <td colspan="1" rowspan="1">Ems</td>
              <td colspan="2" rowspan="1">Relative length in <em>ems</em></td>
            </tr>
            
            <tr>
              <td colspan="1" rowspan="1"></td>
              <td colspan="1" rowspan="1">IntegerType</td>
              <td colspan="1" rowspan="1"></td>
            </tr>
            
            <tr>
              <td colspan="1" rowspan="1"></td>
              <td colspan="1" rowspan="1">Length</td>
              <td colspan="2" rowspan="1">In centimetres(cm), millimetres(mm),
                inches(in), points(pt), picas(pc) or pixels(px)</td>
            </tr>
            
            <tr>
              <td colspan="1" rowspan="1"></td>
              <td colspan="1" rowspan="1">Percentage</td>
              <td colspan="1" rowspan="1"></td>
            </tr>
  
            <tr>
              <th colspan="1" rowspan="1">Other Numeric</th>
              <td colspan="3" rowspan="1">
                Other numeric vaues which do not interact with the
                lengths represented by <em>Numeric</em> values.
              </td>
            </tr>
            
            <tr>
              <td colspan="1" rowspan="1"></td>
              <td colspan="1" rowspan="1">Angle</td>
              <td colspan="2" rowspan="1">In degrees(deg), gradients(grad) or
                radians(rad)</td>
            </tr>
            
            <tr>
              <td colspan="1" rowspan="1"></td>
              <td colspan="1" rowspan="1">Frequency</td>
              <td colspan="2" rowspan="1">In hertz(Hz) or kilohertz(kHz)</td>
            </tr>
            
            <tr>
              <td colspan="1" rowspan="1"></td>
              <td colspan="1" rowspan="1">Time</td>
              <td colspan="1" rowspan="1">In seconds(s) or milliseconds(ms)</td>
            </tr>
            
            <tr>
              <th colspan="2" rowspan="1">Strings</th>
            </tr>
            
            <tr>
              <th colspan="1" rowspan="1">StringType</th>
              <td colspan="3" rowspan="1">
                Base class for data types which result in a <em>String</em>.
              </td>
            </tr>
            
            <tr>
              <td colspan="1" rowspan="1"></td>
              <th colspan="1" rowspan="1">Literal</th>
              <td colspan="2" rowspan="1">
                A subclass of <em>StringType</em> for literals which
                exceed the constraints of an <em>NCName</em>.
              </td>
            </tr>
            
            <tr>
              <td colspan="1" rowspan="1"></td>
              <th colspan="1" rowspan="1">MimeType</th>
              <td colspan="2" rowspan="1">
                A subclass of <em>StringType</em> for literals which
                represent a mime type.
              </td>
            </tr>
            
            <tr>
              <td colspan="1" rowspan="1"></td>
              <th colspan="1" rowspan="1">UriType</th>
              <td colspan="2" rowspan="1">
                A subclass of <em>StringType</em> for literals which
                represent a URI, as specified by the argument to
                <em>url()</em>.
              </td>
            </tr>
            
            <tr>
              <td colspan="1" rowspan="1"></td>
              <th colspan="1" rowspan="1">NCName</th>
              <td colspan="2" rowspan="1">
                A subclass of <em>StringType</em> for literals which
                meet the constraints of an <em>NCName</em>.
              </td>
            </tr>
            
            <tr>
              <td colspan="1" rowspan="1"></td>
              <td colspan="1" rowspan="1"></td>
              <th colspan="1" rowspan="1">Country</th>
              <td colspan="1" rowspan="1">An RFC 3066/ISO 3166 country code.</td>
            </tr>
            
            <tr>
              <td colspan="1" rowspan="1"></td>
              <td colspan="1" rowspan="1"></td>
              <th colspan="1" rowspan="1">Language</th>
              <td colspan="1" rowspan="1">An RFC 3066/ISO 639 language code.</td>
            </tr>
            
            <tr>
              <td colspan="1" rowspan="1"></td>
              <td colspan="1" rowspan="1"></td>
              <th colspan="1" rowspan="1">Script</th>
              <td colspan="1" rowspan="1">An ISO 15924 script code.</td>
            </tr>
            
            <tr>
              <th colspan="2" rowspan="1">Enumerated types</th>
            </tr>
            
            <tr>
              <th colspan="1" rowspan="1">EnumType</th>
              <td colspan="3" rowspan="1">
                An integer representing one of the tokens in a set of
                enumeration values.
              </td>
            </tr>
            
            <tr>
              <td colspan="1" rowspan="1"></td>
              <th colspan="1" rowspan="1">MappedNumeric</th>
              <td colspan="2" rowspan="1">
                A subclass of <em>EnumType</em>.  Maintains a
                <em>Numeric</em> with the value to which the associated
                "raw" enumeration token maps.  E.g., the
                <em>font-size</em> enumeration value "medium" maps to
                the <em>Numeric</em> "12pt".
              </td>
            </tr>
            
            <tr>
              <th colspan="2" rowspan="1">Colors</th>
            </tr>
            
            <tr>
              <th colspan="1" rowspan="1">ColorType</th>
              <td colspan="3" rowspan="1">
                Maintains a four-element array of float, derived from
                the name of a standard colour, the name returned by a
                call to <em>system-color()</em>, or an RGB
                specification.
              </td>
            </tr>
            
            <tr>
              <th colspan="2" rowspan="1">Fonts</th>
            </tr>
            
            <tr>
              <th colspan="1" rowspan="1">FontFamilySet</th>
              <td colspan="3" rowspan="1">
                Maintains an array of <em>String</em>s containing a
                prioritized list of possibly generic font family names.
              </td>
            </tr>
            
            <tr>
              <th colspan="2" rowspan="1">Pseudo-types</th>
            </tr>
            
            <tr>
              <td colspan="4" rowspan="1">
                A variety of pseudo-types have been defined as
                convenience types for frequently appearing enumeration
                token values, or for other special purposes.
              </td>
            </tr>
            
            <tr>
              <th colspan="1" rowspan="1">Inherit</th>
              <td colspan="3" rowspan="1">
                For values of <em>inherit</em>.
              </td>
            </tr>
            
            <tr>
              <th colspan="1" rowspan="1">Auto</th>
              <td colspan="3" rowspan="1">
                For values of <em>auto</em>.
              </td>
            </tr>
            
            <tr>
              <th colspan="1" rowspan="1">None</th>
              <td colspan="3" rowspan="1">
                For values of <em>none</em>.
              </td>
            </tr>
            
            <tr>
              <th colspan="1" rowspan="1">Bool</th>
              <td colspan="3" rowspan="1">
                For values of <em>true/false</em>.
              </td>
            </tr>
            
            <tr>
              <th colspan="1" rowspan="1">FromNearestSpecified</th>
              <td colspan="3" rowspan="1">
                Created to ensure that, when associated with
                a shorthand, the <em>from-nearest-specified-value()</em>
                core function is the sole component of the expression.
              </td>
            </tr>
            
            <tr>
              <th colspan="1" rowspan="1">FromParent</th>
              <td colspan="3" rowspan="1">
                Created to ensure that, when associated with
                a shorthand, the <em>from-parent()</em>
                core function is the sole component of the expression.
              </td>
            </tr>
            
        </table>
        <a name="N10252"></a>
        <h4>Tokenizer</h4>
        <p>
          As mentioned above, the <span class= "codefrag"
          >PropertyTokenizer</span> hands <a href=
          "javascript:parent.displayCode( 'PropertyTokenizer.html#EOF'
          )" ><em>tokens</em></a> back to its subclass, <span class=
          "codefrag" >PropertyParser</span>.  Most of these tokens are
          self-explanatory, but a few need further comment.
        </p>
        <dl>
          
          <dt>AUTO</dt>
          
          <dd>
            Because of its frequency of occurrence, and the fact that it
            is always the <em>initial value</em> for any property which
            supports it, AUTO has been promoted into a pseudo-type with
            its on datatype class.  Therefore, it is also reported as a
            token.
          </dd>
          
          <dt>NONE</dt>
          
          <dd>
            Similarly to AUTO, NONE has been promoted to a pseudo-type
            because of its frequency.
          </dd>
          
          <dt>BOOL</dt>
          
          <dd>
            There is a <em>de facto</em> boolean type buried in the
            enumeration types for many of the properties.  It had been
            specified as a type in its own right in this code.
          </dd>
          
          <dt>MIMETYPE</dt>
          
          <dd>
            The property <span class= "codefrag" >content-type</span>
            introduces this complication.  It can have two values of the
            form <strong>content-type:</strong><em>mime-type</em>
            (e.g. <span class= "codefrag"
            >content-type="content-type:xml/svg"</span>) or
            <strong>namespace-prefix:</strong><em>prefix</em>
            (e.g. <span class= "codefrag"
            >content-type="namespace-prefix:svg"</span>).  The
            experimental code reduces these options to the payload in
            each case: an <span class= "codefrag" >NCName</span> in the
            case of a namespace prefix, and a MIMETYPE in the case of a
            content-type specification.  <span class= "codefrag"
            >NCName</span>s cannot contain a "/".
          </dd>
          
        </dl>
        <a name="N1029C"></a>
        <h4>Parser</h4>
        <p>
          The parser returns a <a href= "javascript:parent.displayCode(
          'PropertyValueList.html#PropertyValueListClass' )" ><span
          class= "codefrag" >PropertyValueList</span ></a>, necessary
          because of the possibility that a list of <a href=
          "javascript:parent.displayCode(
          'PropertyValue.html#PropertyValueInterface' )" ><span class=
          "codefrag" >PropertyValue</span ></a> elements may be returned
          from the expressions of some properties.
        </p>
        <p>
          
          <span class= "codefrag" >PropertyValueList</span>s may contain
          <span class= "codefrag" >PropertyValue</span>s or other <span
          class= "codefrag" >PropertyValueList</span>s.  This latter
          provision is necessitated by some of the more peculiar
          expression possibilities, <em>e.g.</em> <em>font</em> and
          <em>text-shadow</em>.  <em>text-shadow</em> may contain whitespace
          separated sublists of either two or three elements, separated
          from one another by commas.  To accommodate this peculiarity,
          comma separated elements are added to the top-level list,
          while whitespace separated values are always collected into
          sublists to be added to the top-level list.
        </p>
        <p>
          Other special cases include the processing of the core
          functions <span class= "codefrag" >from-parent()</span> and
          <span class= "codefrag" >from-nearest-specified-value()</span>
          when these function calls are assigned to a shorthand
          property, or used with a shorthand property name as an
          argument.  In these cases, the function call must be the sole
          component of the expression.  The pseudo-element classes <span
          class= "codefrag" >FromParent</span> and <span
          class= "codefrag" >FromNearestSpecified</span> are generated in
          these circumstances so that an exception will be thrown if
          they are involved in expression evaluation with other
          components. (See Rec. Section 5.10.4 Property Value
          Functions.)
        </p>
        <p>
          The experimental code is a simple extension of the existing
          parser code, which itself borrowed heavily from James
          Clark's XT processor.
        </p>
        
      </div>
      <table summary="footer" cellspacing="0" cellpadding="0" width="100%" height="20" border="0">
          <tr>
            <td colspan="2" height="1" bgcolor="#4C6C8F"><img height="1"
            width="1" alt="" src="../../../skin/images/spacer.gif"><a
            href="../../../skin/images/label.gif"></a><a
            href="../../../skin/images/page.gif"></a><a
            href="../../../skin/images/chapter.gif"></a><a
            href="../../../skin/images/chapter_open.gif"></a><a
            href="../../../skin/images/current.gif"></a><a
            href="../../..//favicon.ico"></a></td>
          </tr>
          <tr>
            <td colspan="2" bgcolor="#CFDCED" class="copyright"
            align="center"><font size="2" face="Arial, Helvetica,
            Sans-Serif">Copyright &copy; 1999-2002&nbsp;The Apache
            Software Foundation. All rights reserved.<script
            type="text/javascript" language="JavaScript"><!--
            document.write(" - "+"Last Published: " +
            document.lastModified); // --></script></font></td>
          </tr>
          <tr>
            <td align="left" bgcolor="#CFDCED" class="logos"></td><td
            align="right" bgcolor="#CFDCED" class="logos"></td>
          </tr>
      </table>
    </body>
  </html>
  
  
  
  1.1                  xml-site/targets/fop/design/alt.design/properties/Property.html
  
  Index: Property.html
  ===================================================================
  <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN">
  <!-- Created by htmlize-0.67 in css mode. -->
  <html>
    <head>
      <title>Property.java</title>
      <style type="text/css">
      <!--
        body {
          color: #000000;
          background-color: #faf0e6;
        } /* default */
        .variable-name {
          color: #8b008b;
          background-color: #faf0e6;
        } /* font-lock-variable-name-face */
        .jde-java-font-lock-package {
          color: #0000cd;
          background-color: #faf0e6;
        } /* jde-java-font-lock-package-face */
        .jde-java-font-lock-constant {
          color: #5f9ea0;
          background-color: #faf0e6;
        } /* jde-java-font-lock-constant-face */
        .keyword {
          color: #8b0000;
          background-color: #faf0e6;
        } /* font-lock-keyword-face */
        .jde-java-font-lock-doc-tag {
          color: #008b00;
          background-color: #faf0e6;
        } /* jde-java-font-lock-doc-tag-face */
        .string {
          color: #008b00;
          background-color: #faf0e6;
        } /* font-lock-string-face */
        .jde-java-font-lock-number {
          color: #bc8f8f;
          background-color: #faf0e6;
        } /* jde-java-font-lock-number-face */
        .jde-java-font-lock-code {
          background-color: #faf0e6;
        } /* jde-java-font-lock-code-face */
        .type {
          color: #4682b4;
          background-color: #faf0e6;
        } /* font-lock-type-face */
        .jde-java-font-lock-italic {
          background-color: #faf0e6;
          font-style: italic;
        } /* jde-java-font-lock-italic-face */
        .reference {
          color: #cd0000;
          background-color: #faf0e6;
        } /* font-lock-reference-face */
        .jde-java-font-lock-modifier {
          color: #da70d6;
          background-color: #faf0e6;
        } /* jde-java-font-lock-modifier-face */
        .comment {
          color: #00008b;
          background-color: #faf0e6;
        } /* font-lock-comment-face */
        .function-name {
          color: #8b2323;
          background-color: #faf0e6;
        } /* font-lock-function-name-face */
        a {
          color: inherit;
          background-color: inherit;
          font: inherit;
          text-decoration: inherit;
        }
        a:hover {
          text-decoration: underline;
        }
      -->
      </style>
    </head>
    <body>
      <pre>
  <span class="comment">/*
   * $Id: Property.html,v 1.1 2003/01/24 10:46:48 pbwest Exp $
   * Copyright (C) 2001 The Apache Software Foundation. All rights reserved.
   * For details on use and redistribution please refer to the
   * LICENSE file included with these sources.
   *
   * @author &lt;a href=&quot;mailto:pbwest@powerup.com.au&quot;&gt;Peter B. West&lt;/a&gt;
   * @version $Revision: 1.1 $ $Name:  $
   */</span>
  
  <span class="keyword">package</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="jde-java-font-lock-package">properties</span>;
  
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">java</span>.<span class="jde-java-font-lock-package">lang</span>.<span class="type">Class</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">java</span>.<span class="jde-java-font-lock-package">lang</span>.<span class="jde-java-font-lock-package">reflect</span>.<span class="type">Method</span>;
  
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">java</span>.<span class="jde-java-font-lock-package">util</span>.<span class="type">Iterator</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">java</span>.<span class="jde-java-font-lock-package">util</span>.<span class="type">ListIterator</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">java</span>.<span class="jde-java-font-lock-package">util</span>.<span class="type">HashMap</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">java</span>.<span class="jde-java-font-lock-package">util</span>.<span class="type">Map</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">java</span>.<span class="jde-java-font-lock-package">util</span>.<span class="type">LinkedList</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">java</span>.<span class="jde-java-font-lock-package">util</span>.<span class="type">Collections</span>;
  
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">messaging</span>.<span class="type">MessageHandler</span>;
  
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="type">FONode</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="type">PropNames</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="type">PropertyConsts</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="type">ShorthandPropSets</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="type">FOTree</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="type">FOPropertySets</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">PropertyValue</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">AbstractPropertyValue</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">PropertyValueList</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="jde-java-font-lock-package">expr</span>.<span class="type">PropertyException</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="jde-java-font-lock-package">expr</span>.<span class="type">PropertyNotImplementedException</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="jde-java-font-lock-package">expr</span>.<span class="type">SystemFontFunction</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datastructs</span>.<span class="type">ROStringArray</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datastructs</span>.<span class="type">ROIntArray</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">Ints</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">NoType</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">StringType</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">NCName</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">CountryType</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">LanguageType</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">ScriptType</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">UriType</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">MimeType</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">Length</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">Ems</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">Percentage</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">Angle</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">EnumType</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">MappedNumeric</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">IntegerType</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">Numeric</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">Bool</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">Literal</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">Auto</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">None</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">ColorType</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">FontFamilySet</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">TextDecorations</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">TextDecorator</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">ShadowEffect</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">Slash</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="jde-java-font-lock-package">indirect</span>.<span class="type">Inherit</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="jde-java-font-lock-package">indirect</span>.<span class="type">InheritedValue</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="jde-java-font-lock-package">indirect</span>.<span class="type">FromParent</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="jde-java-font-lock-package">indirect</span>.<span class="type">FromNearestSpecified</span>;
  
  <span class="comment">/**
   * Parent class for all of the individual property classes.  It also contains
   * sets of integer constants for various types of data.
   */</span>
  
  <span class="jde-java-font-lock-modifier">public</span> <span class="comment">/*abstract*/</span> <span class="keyword">class</span> <span class="function-name" id="PropertyClass">Property</span> {
  
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">String</span> <span class="variable-name" id="tag">tag</span> = &quot;<span class="string">$Name:  $</span>&quot;;
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">String</span> <span class="variable-name" id="revision">revision</span> = &quot;<span class="string">$Revision: 1.1 $</span>&quot;;
  
      <span class="comment">/*
       * The list of property data types.  These are used to form a bitmap of
       * the property data types that are valid for values of each of the
       * properties.
       *
       * Maintain the following list by
       * in XEmacs:
       *  set the region to cover the list, EXCLUDING the final (-ve) value
       *  M-1 M-| followed by the command
       * perl -p -e 'BEGIN{$n=0;$n2=0};$n2=2**$n,$n++ if s/= [0-9]+/= $n2/'
       * in vi:
       *  set a mark (ma) at the end of the list but one.
       * Go to the beginning and
       *  !'aperl -p -e ... etc
       *
       * N.B. The maximum value that can be handled in this way is
       * 2^30 or 1073741824.  The -ve value is the equivalent of 2^31.
       */</span>
      <span class="comment">/**
       * Constant specifying a property data type or types.
       */</span>
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span>
                           <span class="jde-java-font-lock-constant" id="NOTYPE">NOTYPE</span> = <span class="jde-java-font-lock-number">0</span>
                         ,<span class="jde-java-font-lock-constant" id="INTEGER">INTEGER</span> = <span class="jde-java-font-lock-number">1</span>
                           ,<span class="jde-java-font-lock-constant" id="FLOAT">FLOAT</span> = <span class="jde-java-font-lock-number">2</span>
                          ,<span class="jde-java-font-lock-constant" id="LENGTH">LENGTH</span> = <span class="jde-java-font-lock-number">4</span>
                           ,<span class="jde-java-font-lock-constant" id="ANGLE">ANGLE</span> = <span class="jde-java-font-lock-number">8</span>
                      ,<span class="jde-java-font-lock-constant" id="PERCENTAGE">PERCENTAGE</span> = <span class="jde-java-font-lock-number">16</span>
                     ,<span class="jde-java-font-lock-constant" id="CHARACTER_T">CHARACTER_T</span> = <span class="jde-java-font-lock-number">32</span>
                         ,<span class="jde-java-font-lock-constant" id="LITERAL">LITERAL</span> = <span class="jde-java-font-lock-number">64</span>
                          ,<span class="jde-java-font-lock-constant" id="NCNAME">NCNAME</span> = <span class="jde-java-font-lock-number">128</span>
                         ,<span class="jde-java-font-lock-constant" id="COLOR_T">COLOR_T</span> = <span class="jde-java-font-lock-number">256</span>
                       ,<span class="jde-java-font-lock-constant" id="COUNTRY_T">COUNTRY_T</span> = <span class="jde-java-font-lock-number">512</span>
                      ,<span class="jde-java-font-lock-constant" id="LANGUAGE_T">LANGUAGE_T</span> = <span class="jde-java-font-lock-number">1024</span>
                        ,<span class="jde-java-font-lock-constant" id="SCRIPT_T">SCRIPT_T</span> = <span class="jde-java-font-lock-number">2048</span>
               ,<span class="jde-java-font-lock-constant" id="URI_SPECIFICATION">URI_SPECIFICATION</span> = <span class="jde-java-font-lock-number">4096</span>
                            ,<span class="jde-java-font-lock-constant" id="TIME">TIME</span> = <span class="jde-java-font-lock-number">8192</span>
                       ,<span class="jde-java-font-lock-constant" id="FREQUENCY">FREQUENCY</span> = <span class="jde-java-font-lock-number">16384</span>
      <span class="comment">// Pseudotypes
  </span>                          ,<span class="jde-java-font-lock-constant" id="BOOL">BOOL</span> = <span class="jde-java-font-lock-number">32768</span>
                         ,<span class="jde-java-font-lock-constant" id="INHERIT">INHERIT</span> = <span class="jde-java-font-lock-number">65536</span>
                            ,<span class="jde-java-font-lock-constant" id="ENUM">ENUM</span> = <span class="jde-java-font-lock-number">131072</span>
                   ,<span class="jde-java-font-lock-constant" id="MAPPED_LENGTH">MAPPED_LENGTH</span> = <span class="jde-java-font-lock-number">262144</span>
                       ,<span class="jde-java-font-lock-constant" id="SHORTHAND">SHORTHAND</span> = <span class="jde-java-font-lock-number">524288</span>
                         ,<span class="jde-java-font-lock-constant" id="COMPLEX">COMPLEX</span> = <span class="jde-java-font-lock-number">1048576</span>
                            ,<span class="jde-java-font-lock-constant" id="AUTO">AUTO</span> = <span class="jde-java-font-lock-number">2097152</span>
                            ,<span class="jde-java-font-lock-constant" id="NONE">NONE</span> = <span class="jde-java-font-lock-number">4194304</span>
                           ,<span class="jde-java-font-lock-constant" id="AURAL">AURAL</span> = <span class="jde-java-font-lock-number">8388608</span>
      <span class="comment">// Color plus transparent
  </span>                   ,<span class="jde-java-font-lock-constant" id="COLOR_TRANS">COLOR_TRANS</span> = <span class="jde-java-font-lock-number">16777216</span>
                        ,<span class="jde-java-font-lock-constant" id="MIMETYPE">MIMETYPE</span> = <span class="jde-java-font-lock-number">33554432</span>
                         ,<span class="jde-java-font-lock-constant" id="FONTSET">FONTSET</span> = <span class="jde-java-font-lock-number">67108864</span>
                        ,<span class="jde-java-font-lock-constant" id="COMPOUND">COMPOUND</span> = <span class="jde-java-font-lock-number">134217728</span>
      <span class="comment">//                   ,SPARE = 268435456
  </span>    <span class="comment">//                   ,SPARE = 536870912
  </span>    <span class="comment">//                   ,SPARE = 1073741824
  </span>    <span class="comment">//                   ,SPARE = -2147483648
  </span>
      <span class="comment">// A number of questions are unresolved about the interaction of
  </span>    <span class="comment">// complex parsing, property expression parsing &amp; property validation.
  </span>    <span class="comment">// At this time (2002/07/03) it looks as though the refineParsing() method
  </span>    <span class="comment">// will take full validation responsibility, so it will not be
  </span>    <span class="comment">// necessary to specify any individual datatypes besides COMPLEX in the
  </span>    <span class="comment">// property dataTypes field.  This renders some such specifications
  </span>    <span class="comment">// redundant.  On the other hand, if such individual datatype validation
  </span>    <span class="comment">// becomes necessary, the datatype settings for properties with COMPLEX
  </span>    <span class="comment">// will have to be adjusted.  pbw
  </span>
                          ,<span class="jde-java-font-lock-constant" id="NUMBER">NUMBER</span> = <span class="jde-java-font-lock-constant">FLOAT</span> | <span class="type">INTEGER</span>
                       ,<span class="jde-java-font-lock-constant" id="ENUM_TYPE">ENUM_TYPE</span> = <span class="jde-java-font-lock-constant">ENUM</span> | <span class="type">MAPPED_LENGTH</span>
                          ,<span class="jde-java-font-lock-constant" id="STRING">STRING</span> = <span class="jde-java-font-lock-constant">LITERAL</span> | <span class="type">NCNAME</span>
                       ,<span class="jde-java-font-lock-constant" id="HYPH_TYPE">HYPH_TYPE</span> = <span class="jde-java-font-lock-constant">COUNTRY_T</span> | <span class="jde-java-font-lock-constant">LANGUAGE_T</span> | <span class="type">SCRIPT_T</span>
                       ,<span class="jde-java-font-lock-constant" id="NAME_TYPE">NAME_TYPE</span> = <span class="jde-java-font-lock-constant">NCNAME</span> | <span class="jde-java-font-lock-constant">HYPH_TYPE</span> | <span class="type">ENUM_TYPE</span>
                     ,<span class="jde-java-font-lock-constant" id="STRING_TYPE">STRING_TYPE</span> = <span class="jde-java-font-lock-constant">STRING</span> | <span class="type">NAME_TYPE</span>
                        ,<span class="jde-java-font-lock-constant" id="ANY_TYPE">ANY_TYPE</span> = ~<span class="jde-java-font-lock-number">0</span>
                                  ;
  
      <span class="comment">/** Constant specifying an initial data type. */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span>
                        <span class="jde-java-font-lock-constant" id="NOTYPE_IT">NOTYPE_IT</span> = <span class="jde-java-font-lock-number">0</span>
                      ,<span class="jde-java-font-lock-constant" id="INTEGER_IT">INTEGER_IT</span> = <span class="jde-java-font-lock-number">1</span>
                       ,<span class="jde-java-font-lock-constant" id="NUMBER_IT">NUMBER_IT</span> = <span class="jde-java-font-lock-number">2</span>
                       ,<span class="jde-java-font-lock-constant" id="LENGTH_IT">LENGTH_IT</span> = <span class="jde-java-font-lock-number">4</span>
                        ,<span class="jde-java-font-lock-constant" id="ANGLE_IT">ANGLE_IT</span> = <span class="jde-java-font-lock-number">8</span>
                   ,<span class="jde-java-font-lock-constant" id="PERCENTAGE_IT">PERCENTAGE_IT</span> = <span class="jde-java-font-lock-number">16</span>
                    ,<span class="jde-java-font-lock-constant" id="CHARACTER_IT">CHARACTER_IT</span> = <span class="jde-java-font-lock-number">32</span>
                      ,<span class="jde-java-font-lock-constant" id="LITERAL_IT">LITERAL_IT</span> = <span class="jde-java-font-lock-number">64</span>
                       ,<span class="jde-java-font-lock-constant" id="NCNAME_IT">NCNAME_IT</span> = <span class="jde-java-font-lock-number">128</span>
                        ,<span class="jde-java-font-lock-constant" id="COLOR_IT">COLOR_IT</span> = <span class="jde-java-font-lock-number">256</span>
                      ,<span class="jde-java-font-lock-constant" id="COUNTRY_IT">COUNTRY_IT</span> = <span class="jde-java-font-lock-number">512</span>
            ,<span class="jde-java-font-lock-constant" id="URI_SPECIFICATION_IT">URI_SPECIFICATION_IT</span> = <span class="jde-java-font-lock-number">1024</span>
                         ,<span class="jde-java-font-lock-constant" id="BOOL_IT">BOOL_IT</span> = <span class="jde-java-font-lock-number">2048</span>
                         ,<span class="jde-java-font-lock-constant" id="ENUM_IT">ENUM_IT</span> = <span class="jde-java-font-lock-number">4096</span>
                         ,<span class="jde-java-font-lock-constant" id="AUTO_IT">AUTO_IT</span> = <span class="jde-java-font-lock-number">8192</span>
                         ,<span class="jde-java-font-lock-constant" id="NONE_IT">NONE_IT</span> = <span class="jde-java-font-lock-number">16384</span>
                        ,<span class="jde-java-font-lock-constant" id="AURAL_IT">AURAL_IT</span> = <span class="jde-java-font-lock-number">32768</span>
              ,<span class="jde-java-font-lock-constant" id="TEXT_DECORATION_IT">TEXT_DECORATION_IT</span> = <span class="jde-java-font-lock-number">65536</span>
    <span class="comment">// Unused         ,FONTSET_IT = 131072
  </span>                                ;
  
      <span class="comment">/**
       * Bitmap set of initial data types for which getInitialType() must be
       * overriden.
       */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span>
              <span class="jde-java-font-lock-constant" id="USE_GET_IT_FUNCTION">USE_GET_IT_FUNCTION</span> = <span class="comment">//NOTYPE_IT performed in Property
  </span>                                    <span class="type">INTEGER_IT</span>
                                    | <span class="type">NUMBER_IT</span>
                                    | <span class="type">LENGTH_IT</span>
                                    | <span class="type">ANGLE_IT</span>
                                    | <span class="type">PERCENTAGE_IT</span>
                                    | <span class="type">CHARACTER_IT</span>
                                    | <span class="type">LITERAL_IT</span>
                                    | <span class="type">NCNAME_IT</span>
                                    | <span class="type">COLOR_IT</span>
                                    | <span class="type">COUNTRY_IT</span>
                                    | <span class="type">URI_SPECIFICATION_IT</span>
                                    | <span class="type">BOOL_IT</span>
                                    | <span class="type">ENUM_IT</span>
                                    <span class="comment">//AUTO_IT  performed in Property
  </span>                                  <span class="comment">//NONE_IT  performed in Property
  </span>                                  <span class="comment">//AURAL_IT  performed in Property
  </span>                                  | <span class="type">TEXT_DECORATION_IT</span>
                                ;
  
      <span class="comment">/** Constant specifying mapping of property to trait. */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span>
                         <span class="jde-java-font-lock-constant" id="NO_TRAIT">NO_TRAIT</span> = <span class="jde-java-font-lock-number">0</span>
                       ,<span class="jde-java-font-lock-constant" id="RENDERING">RENDERING</span> = <span class="jde-java-font-lock-number">1</span>
                      ,<span class="jde-java-font-lock-constant" id="DISAPPEARS">DISAPPEARS</span> = <span class="jde-java-font-lock-number">2</span>
                   ,<span class="jde-java-font-lock-constant" id="SHORTHAND_MAP">SHORTHAND_MAP</span> = <span class="jde-java-font-lock-number">4</span>
                          ,<span class="jde-java-font-lock-constant" id="REFINE">REFINE</span> = <span class="jde-java-font-lock-number">8</span>
                      ,<span class="jde-java-font-lock-constant" id="FORMATTING">FORMATTING</span> = <span class="jde-java-font-lock-number">16</span>
                   ,<span class="jde-java-font-lock-constant" id="SPECIFICATION">SPECIFICATION</span> = <span class="jde-java-font-lock-number">32</span>
                       ,<span class="jde-java-font-lock-constant" id="NEW_TRAIT">NEW_TRAIT</span> = <span class="jde-java-font-lock-number">64</span>
                  ,<span class="jde-java-font-lock-constant" id="FONT_SELECTION">FONT_SELECTION</span> = <span class="jde-java-font-lock-number">128</span>
                    ,<span class="jde-java-font-lock-constant" id="VALUE_CHANGE">VALUE_CHANGE</span> = <span class="jde-java-font-lock-number">256</span>
                       ,<span class="jde-java-font-lock-constant" id="REFERENCE">REFERENCE</span> = <span class="jde-java-font-lock-number">512</span>
                          ,<span class="jde-java-font-lock-constant" id="ACTION">ACTION</span> = <span class="jde-java-font-lock-number">1024</span>
                           ,<span class="jde-java-font-lock-constant" id="MAGIC">MAGIC</span> = <span class="jde-java-font-lock-number">2048</span>
                                ;
  
      <span class="comment">/*
       * Constant specifying inheritance type.  Special cases (only line-height
       * specified as a &amp;lt;number&amp;gt;, so far) must be handled close to the
       * usage point of the property.  For line-height, the number is retained
       * as the specified and as the computed property value.  Because the
       * current font-size will always be present in the property set for any
       * FONode which requires line-height, the actual length value of the
       * line-height can always be calculated at the point of application.
       */</span>
      <span class="comment">/** Constant specifying inheritance type.  */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span>
                               <span class="jde-java-font-lock-constant" id="NO">NO</span> = <span class="jde-java-font-lock-number">0</span>
                        ,<span class="jde-java-font-lock-constant" id="COMPUTED">COMPUTED</span> = <span class="jde-java-font-lock-number">1</span>
                                ;
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span> <span class="variable-name" id="dataTypes">dataTypes</span> = <span class="jde-java-font-lock-constant">NOTYPE</span>;
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span> <span class="variable-name" id="initialValueType">initialValueType</span> = <span class="jde-java-font-lock-constant">NOTYPE_IT</span>;
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span> <span class="variable-name" id="inherited">inherited</span> = <span class="jde-java-font-lock-constant">NO</span>;
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="type">Map</span> <span class="variable-name" id="enumHash">enumHash</span> = <span class="jde-java-font-lock-constant" id="null">null</span>;
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="function-name" id="Property">Property</span>() {}
  
      <span class="comment">/**
       * Form a string representation of bitmap of datatypes.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="datatypes">datatypes</span><span class="comment"> - a bitmap of datatype(s).
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> &lt;tt&gt;String&lt;/tt&gt; containing a list of text names of datatypes
       * found in the bitmap.  Individual names are enclosed in angle brackets
       * and separated by a vertical bar.  Psuedo-datatypes are in upper case.
       * </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">PropertyException</span><span class="comment"> if no matches are found.
       */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="type">String</span> <span class="function-name" id="listDataTypes">listDataTypes</span>(<span class="type">int</span> <span class="variable-name">datatypes</span>)
                      <span class="keyword">throws</span> <span class="type">PropertyException</span>
      {
          <span class="type">String</span> <span class="variable-name" id="typeNames">typeNames</span> = &quot;&quot;;
          <span class="keyword">if</span> ((datatypes &amp; <span class="jde-java-font-lock-constant">ANY_TYPE</span>) == <span class="type">ANY_TYPE</span>) <span class="keyword">return</span> &quot;<span class="string">&lt;ALL-TYPES&gt;</span>&quot;;
          <span class="keyword">if</span> ((datatypes &amp; <span class="jde-java-font-lock-constant">INTEGER</span>) != <span class="jde-java-font-lock-number">0</span>) typeNames += &quot;<span class="string">&lt;integer&gt;|</span>&quot;;
          <span class="keyword">if</span> ((datatypes &amp; <span class="jde-java-font-lock-constant">NUMBER</span>) != <span class="jde-java-font-lock-number">0</span>) typeNames += &quot;<span class="string">&lt;number&gt;|</span>&quot;;
          <span class="keyword">if</span> ((datatypes &amp; <span class="jde-java-font-lock-constant">LENGTH</span>) != <span class="jde-java-font-lock-number">0</span>) typeNames += &quot;<span class="string">&lt;length&gt;|</span>&quot;;
          <span class="keyword">if</span> ((datatypes &amp; <span class="jde-java-font-lock-constant">ANGLE</span>) != <span class="jde-java-font-lock-number">0</span>) typeNames += &quot;<span class="string">&lt;angle&gt;|</span>&quot;;
          <span class="keyword">if</span> ((datatypes &amp; <span class="jde-java-font-lock-constant">PERCENTAGE</span>) != <span class="jde-java-font-lock-number">0</span>) typeNames += &quot;<span class="string">&lt;percentage&gt;|</span>&quot;;
          <span class="keyword">if</span> ((datatypes &amp; <span class="jde-java-font-lock-constant">CHARACTER_T</span>) != <span class="jde-java-font-lock-number">0</span>) typeNames += &quot;<span class="string">&lt;character&gt;|</span>&quot;;
          <span class="keyword">if</span> ((datatypes &amp; <span class="jde-java-font-lock-constant">STRING</span>) != <span class="jde-java-font-lock-number">0</span>) typeNames += &quot;<span class="string">&lt;string&gt;|</span>&quot;;
          <span class="keyword">if</span> ((datatypes &amp; <span class="jde-java-font-lock-constant">NCNAME</span>) != <span class="jde-java-font-lock-number">0</span>) typeNames += &quot;<span class="string">&lt;ncname&gt;|</span>&quot;;
          <span class="keyword">if</span> ((datatypes &amp; <span class="jde-java-font-lock-constant">COLOR_T</span>) != <span class="jde-java-font-lock-number">0</span>) typeNames += &quot;<span class="string">&lt;color&gt;|</span>&quot;;
          <span class="keyword">if</span> ((datatypes &amp; <span class="jde-java-font-lock-constant">COUNTRY_T</span>) != <span class="jde-java-font-lock-number">0</span>) typeNames += &quot;<span class="string">&lt;country&gt;|</span>&quot;;
          <span class="keyword">if</span> ((datatypes &amp; <span class="jde-java-font-lock-constant">LANGUAGE_T</span>) != <span class="jde-java-font-lock-number">0</span>) typeNames += &quot;<span class="string">&lt;language&gt;|</span>&quot;;
          <span class="keyword">if</span> ((datatypes &amp; <span class="jde-java-font-lock-constant">SCRIPT_T</span>) != <span class="jde-java-font-lock-number">0</span>) typeNames += &quot;<span class="string">&lt;script&gt;|</span>&quot;;
          <span class="keyword">if</span> ((datatypes &amp; <span class="jde-java-font-lock-constant">URI_SPECIFICATION</span>) != <span class="jde-java-font-lock-number">0</span>) typeNames
                                                      += &quot;<span class="string">&lt;uri-specification&gt;|</span>&quot;;
          <span class="keyword">if</span> ((datatypes &amp; <span class="jde-java-font-lock-constant">TIME</span>) != <span class="jde-java-font-lock-number">0</span>) typeNames += &quot;<span class="string">&lt;time&gt;|</span>&quot;;
          <span class="keyword">if</span> ((datatypes &amp; <span class="jde-java-font-lock-constant">FREQUENCY</span>) != <span class="jde-java-font-lock-number">0</span>) typeNames += &quot;<span class="string">&lt;frequency&gt;|</span>&quot;;
          <span class="keyword">if</span> ((datatypes &amp; <span class="jde-java-font-lock-constant">BOOL</span>) != <span class="jde-java-font-lock-number">0</span>) typeNames += &quot;<span class="string">&lt;BOOL&gt;|</span>&quot;;
          <span class="keyword">if</span> ((datatypes &amp; <span class="jde-java-font-lock-constant">INHERIT</span>) != <span class="jde-java-font-lock-number">0</span>) typeNames += &quot;<span class="string">&lt;INHERIT&gt;|</span>&quot;;
          <span class="keyword">if</span> ((datatypes &amp; <span class="jde-java-font-lock-constant">ENUM</span>) != <span class="jde-java-font-lock-number">0</span>) typeNames += &quot;<span class="string">&lt;ENUM&gt;|</span>&quot;;
          <span class="keyword">if</span> ((datatypes &amp; <span class="jde-java-font-lock-constant">MAPPED_LENGTH</span>) != <span class="jde-java-font-lock-number">0</span>) typeNames
                                                      += &quot;<span class="string">&lt;MAPPED_LENGTH&gt;|</span>&quot;;
          <span class="keyword">if</span> ((datatypes &amp; <span class="jde-java-font-lock-constant">SHORTHAND</span>) != <span class="jde-java-font-lock-number">0</span>) typeNames += &quot;<span class="string">&lt;SHORTHAND&gt;|</span>&quot;;
          <span class="keyword">if</span> ((datatypes &amp; <span class="jde-java-font-lock-constant">COMPLEX</span>) != <span class="jde-java-font-lock-number">0</span>) typeNames += &quot;<span class="string">&lt;COMPLEX&gt;|</span>&quot;;
          <span class="keyword">if</span> ((datatypes &amp; <span class="jde-java-font-lock-constant">AUTO</span>) != <span class="jde-java-font-lock-number">0</span>) typeNames += &quot;<span class="string">&lt;AUTO&gt;|</span>&quot;;
          <span class="keyword">if</span> ((datatypes &amp; <span class="jde-java-font-lock-constant">NONE</span>) != <span class="jde-java-font-lock-number">0</span>) typeNames += &quot;<span class="string">&lt;NONE&gt;|</span>&quot;;
          <span class="keyword">if</span> ((datatypes &amp; <span class="jde-java-font-lock-constant">AURAL</span>) != <span class="jde-java-font-lock-number">0</span>) typeNames += &quot;<span class="string">&lt;AURAL&gt;|</span>&quot;;
          <span class="keyword">if</span> ((datatypes &amp; <span class="jde-java-font-lock-constant">COLOR_TRANS</span>) != <span class="jde-java-font-lock-number">0</span>) typeNames += &quot;<span class="string">&lt;COLOR_TRANS&gt;|</span>&quot;;
          <span class="keyword">if</span> ((datatypes &amp; <span class="jde-java-font-lock-constant">MIMETYPE</span>) != <span class="jde-java-font-lock-number">0</span>) typeNames += &quot;<span class="string">&lt;MIMETYPE&gt;|</span>&quot;;
          <span class="keyword">if</span> ((datatypes &amp; <span class="jde-java-font-lock-constant">FONTSET</span>) != <span class="jde-java-font-lock-number">0</span>) typeNames += &quot;<span class="string">&lt;FONTSET&gt;|</span>&quot;;
  
          <span class="keyword">if</span> (typeNames == &quot;&quot;) <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>
                              (&quot;<span class="string">No valid data type in </span>&quot; + datatypes);
          <span class="keyword">return</span> typeNames.substring(<span class="jde-java-font-lock-number">0</span>, typeNames.length() - <span class="jde-java-font-lock-number">1</span>);
      }
  
      <span class="comment">/**
       * Derive inherited value for the given property.
       * This method must be overriden by properties with special requirements.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="foTree">foTree</span><span class="comment"> the &lt;tt&gt;FOTree&lt;/tt&gt; being built
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="property">property</span><span class="comment"> the &lt;tt&gt;int&lt;/tt&gt; property index
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> &lt;tt&gt;PropertyValue&lt;/tt&gt; the inherited property value for the
       * property.  It contains the inherited &lt;i&gt;</span><span class="jde-java-font-lock-italic">computed</span><span class="comment">&lt;/i&gt; value, and no
       * &lt;i&gt;</span><span class="jde-java-font-lock-italic">specified</span><span class="comment">&lt;/i&gt; value.
       * </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">&lt;tt&gt;PropertyException&lt;/tt&gt;
  </span><span class="comment">     */</span>
       <span class="comment">/*
      public static PropertyValue inheritance(FOTree foTree, int property)
              throws PropertyException
      {
          // Is it inherited?  This question is not asked here.  Should it be
          // determined in here or outside?
          return foTree.getCurrentInherited(property);
      }
      */</span>
  
      <span class="comment">/** Constant for nested &lt;tt&gt;refineParsing&lt;/tt&gt; methods. */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="type">boolean</span> <span class="variable-name" id="IS_NESTED">IS_NESTED</span> = <span class="jde-java-font-lock-constant" id="true">true</span>;
  
      <span class="comment">/** Constant for non-nested &lt;tt&gt;refineParsing&lt;/tt&gt; methods. */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="type">boolean</span> <span class="variable-name" id="NOT_NESTED">NOT_NESTED</span> = <span class="jde-java-font-lock-constant" id="false">false</span>;
  
      <span class="comment">/**
       * The final stage of property expression parsing.
       * &lt;ol&gt;
       *   &lt;li&gt;PropertyTokenizer&lt;/li&gt;
       *   &lt;li&gt;PropertyParser - returns context-free &lt;tt&gt;PropertyValue&lt;/tt&gt;s
       *    recognizable by the parser&lt;/li&gt;
       *   &lt;li&gt;refineParsing - verifies results from parser, translates
       *    property types like NCName into more specific value types,
       *    resolves enumeration types, etc.&lt;/li&gt;
       * &lt;/ol&gt;
       *
       * &lt;p&gt;This method is overriden by individual property classes which
       * require specific processing.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="propindex">propindex</span><span class="comment"> - the &lt;tt&gt;int&lt;/tt&gt; property index.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="foNode">foNode</span><span class="comment"> - the &lt;tt&gt;FONode&lt;/tt&gt; being built
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="value">value</span><span class="comment"> - &lt;tt&gt;PropertyValue&lt;/tt&gt; returned by the parser
       */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">PropertyValue</span> <span class="variable-name" id="refineParsing">refineParsing</span>
                          (<span class="type">int</span> <span class="variable-name">propindex</span>, <span class="type">FONode</span> <span class="variable-name">foNode</span>, <span class="type">PropertyValue</span> <span class="variable-name">value</span>)
              <span class="keyword">throws</span> <span class="type">PropertyException</span>
      {
          <span class="keyword">return</span> refineParsing(propindex, foNode, value, <span class="jde-java-font-lock-constant">NOT_NESTED</span>);
      }
  
      <span class="comment">/**
       * Do the work for the three argument refineParsing method.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">property</span><span class="comment"> - the &lt;tt&gt;int&lt;/tt&gt; property index.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">foNode</span><span class="comment"> - the &lt;tt&gt;FONode&lt;/tt&gt; being built
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">value</span><span class="comment"> - &lt;tt&gt;PropertyValue&lt;/tt&gt; returned by the parser
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="nested">nested</span><span class="comment"> - &lt;tt&gt;boolean&lt;/tt&gt; indicating whether this method is
       * called normally (false), or as part of another &lt;i&gt;</span><span class="jde-java-font-lock-italic">refineParsing</span><span class="comment">&lt;/i&gt;
       * method.
       * </span><span class="jde-java-font-lock-doc-tag">@see</span><span class="comment"> </span><span class="jde-java-font-lock-code">#refineParsing</span><span class="comment">(int,FOTree,PropertyValue)
       */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">PropertyValue</span> <span class="function-name">refineParsing</span>(<span class="type">int</span> <span class="variable-name">property</span>,
                          <span class="type">FONode</span> <span class="variable-name">foNode</span>, <span class="type">PropertyValue</span> <span class="variable-name">value</span>, <span class="type">boolean</span> <span class="variable-name">nested</span>)
              <span class="keyword">throws</span> <span class="type">PropertyException</span>
      {
          <span class="comment">//int property = value.getProperty();
  </span>        <span class="keyword">if</span> (property != value.getProperty()) <span class="comment">// DEBUG
  </span>            <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>
                  (&quot;<span class="string">Mismatched property and value.property.</span>&quot;);
          <span class="type">String</span> <span class="variable-name" id="propName">propName</span> = PropNames.getPropertyName(property);
          <span class="type">int</span> <span class="variable-name" id="proptype">proptype</span> = value.getType();
          <span class="type">int</span> <span class="variable-name">dataTypes</span> = PropertyConsts.pconsts.getDataTypes(property);
          <span class="type">PropertyValue</span> <span class="variable-name" id="pv">pv</span>;
          <span class="keyword">if</span> ((dataTypes &amp; <span class="jde-java-font-lock-constant">AURAL</span>) != <span class="jde-java-font-lock-number">0</span>)
              <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyNotImplementedException</span>
                  (&quot;<span class="string">AURAL properties are not supported</span>&quot;);
          <span class="keyword">switch</span> (proptype) {
          <span class="keyword">case</span> <span class="reference">PropertyValue.NUMERIC</span>:
              <span class="comment">// Can be any of
  </span>            <span class="comment">// INTEGER, FLOAT, LENGTH, PERCENTAGE, ANGLE, FREQUENCY or TIME
  </span>            <span class="keyword">if</span> ((dataTypes &amp; (<span class="jde-java-font-lock-constant">INTEGER</span> | <span class="jde-java-font-lock-constant">FLOAT</span> | <span class="jde-java-font-lock-constant">LENGTH</span> | <span class="type">PERCENTAGE</span>
                                  | <span class="jde-java-font-lock-constant">ANGLE</span> | <span class="jde-java-font-lock-constant">FREQUENCY</span> | <span class="jde-java-font-lock-constant">TIME</span>)) != <span class="jde-java-font-lock-number">0</span>)
                  <span class="keyword">return</span> value;
              <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>
                              (&quot;<span class="string">Numeric value invalid  for </span>&quot; + propName);
          <span class="keyword">case</span> <span class="reference">PropertyValue.INTEGER</span>:
              <span class="keyword">if</span> ((dataTypes &amp; <span class="jde-java-font-lock-constant">NUMBER</span>) != <span class="jde-java-font-lock-number">0</span>)
                  <span class="keyword">return</span> value;
              <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>
                      (&quot;<span class="string">IntegerType value invalid for </span>&quot; + propName);
          <span class="keyword">case</span> <span class="reference">PropertyValue.NCNAME</span>:
              <span class="type">String</span> <span class="variable-name" id="ncname">ncname</span> = ((<span class="type">NCName</span>)value).getNCName();
              <span class="comment">// Can by any of
  </span>            <span class="comment">// NCNAME, COUNTRY_T, LANGUAGE_T, SCRIPT_T, ENUM
  </span>            <span class="comment">// MAPPED_LENGTH or CHARACTER_T
  </span>            <span class="keyword">if</span> ((dataTypes &amp; (<span class="jde-java-font-lock-constant">NCNAME</span> | <span class="jde-java-font-lock-constant">CHARACTER_T</span>)) != <span class="jde-java-font-lock-number">0</span>)
                  <span class="keyword">return</span> value;
              <span class="keyword">if</span> ((dataTypes &amp; <span class="jde-java-font-lock-constant">COUNTRY_T</span>) != <span class="jde-java-font-lock-number">0</span>)
                  <span class="keyword">return</span> <span class="keyword">new</span> <span class="type">CountryType</span>(property, ncname);
              <span class="keyword">if</span> ((dataTypes &amp; <span class="jde-java-font-lock-constant">LANGUAGE_T</span>) != <span class="jde-java-font-lock-number">0</span>)
                  <span class="keyword">return</span> <span class="keyword">new</span> <span class="type">LanguageType</span>(property, ncname);
              <span class="keyword">if</span> ((dataTypes &amp; <span class="jde-java-font-lock-constant">SCRIPT_T</span>) != <span class="jde-java-font-lock-number">0</span>)
                  <span class="keyword">return</span> <span class="keyword">new</span> <span class="type">ScriptType</span>(property, ncname);
              <span class="keyword">if</span> ((dataTypes &amp; <span class="jde-java-font-lock-constant">ENUM</span>) != <span class="jde-java-font-lock-number">0</span>)
                  <span class="keyword">return</span> <span class="keyword">new</span> <span class="type">EnumType</span>(property, ncname);
              <span class="keyword">if</span> ((dataTypes &amp; <span class="jde-java-font-lock-constant">MAPPED_LENGTH</span>) != <span class="jde-java-font-lock-number">0</span>)
                  <span class="keyword">return</span> (<span class="keyword">new</span> <span class="type">MappedNumeric</span>
                              (foNode, property, ncname)).getMappedNumValue();
              <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>
                              (&quot;<span class="string">NCName value invalid  for </span>&quot; + propName);
          <span class="keyword">case</span> <span class="reference">PropertyValue.ENUM</span>:
              <span class="keyword">if</span> ((dataTypes &amp; <span class="jde-java-font-lock-constant">ENUM</span>) != <span class="jde-java-font-lock-number">0</span>) <span class="keyword">return</span> value;
              <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>
                      ( &quot;<span class="string">Enumerated value invalid for </span>&quot; + propName);
          <span class="keyword">case</span> <span class="reference">PropertyValue.LITERAL</span>:
              <span class="comment">// Can be LITERAL or CHARACTER_T
  </span>            <span class="keyword">if</span> ((dataTypes &amp; (<span class="jde-java-font-lock-constant">LITERAL</span> | <span class="jde-java-font-lock-constant">CHARACTER_T</span>)) != <span class="jde-java-font-lock-number">0</span>) <span class="keyword">return</span> value;
              <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>
                              (&quot;<span class="string">Literal value invalid  for </span>&quot; + propName);
          <span class="keyword">case</span> <span class="reference">PropertyValue.AUTO</span>:
              <span class="keyword">if</span> ((dataTypes &amp; <span class="jde-java-font-lock-constant">AUTO</span>) != <span class="jde-java-font-lock-number">0</span>) <span class="keyword">return</span> value;
              <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(&quot;<span class="string">'auto' invalid  for </span>&quot; + propName);
          <span class="keyword">case</span> <span class="reference">PropertyValue.BOOL</span>:
              <span class="keyword">if</span> ((dataTypes &amp; <span class="jde-java-font-lock-constant">BOOL</span>) != <span class="jde-java-font-lock-number">0</span>) <span class="keyword">return</span> value;
              <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>
                                  (&quot;<span class="string">Boolean value invalid for </span>&quot; + propName);
          <span class="keyword">case</span> <span class="reference">PropertyValue.COLOR_TYPE</span>:
              <span class="comment">// Can be COLOR_T or COLOR_TRANS
  </span>            <span class="keyword">if</span> ((dataTypes &amp; (<span class="jde-java-font-lock-constant">COLOR_T</span> | <span class="jde-java-font-lock-constant">COLOR_TRANS</span>)) != <span class="jde-java-font-lock-number">0</span>) <span class="keyword">return</span> value;
              <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(&quot;<span class="string">'none' invalid  for </span>&quot; + propName);
          <span class="keyword">case</span> <span class="reference">PropertyValue.NONE</span>:
              <span class="comment">// Some instances of 'none' are part of an enumeration, but
  </span>            <span class="comment">// the parser will find and return 'none' as a None
  </span>            <span class="comment">// PropertyValue.
  </span>            <span class="comment">// In these cases, the individual property's refineParsing
  </span>            <span class="comment">// method must override this method.
  </span>            <span class="keyword">if</span> ((dataTypes &amp; <span class="jde-java-font-lock-constant">NONE</span>) != <span class="jde-java-font-lock-number">0</span>) <span class="keyword">return</span> value;
              <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(&quot;<span class="string">'none' invalid  for </span>&quot; + propName);
          <span class="keyword">case</span> <span class="reference">PropertyValue.URI_TYPE</span>:
              <span class="keyword">if</span> ((dataTypes &amp; <span class="jde-java-font-lock-constant">URI_SPECIFICATION</span>) != <span class="jde-java-font-lock-number">0</span>) <span class="keyword">return</span> value;
              <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(&quot;<span class="string">uri invalid for </span>&quot; + propName);
          <span class="keyword">case</span> <span class="reference">PropertyValue.MIME_TYPE</span>:
              <span class="keyword">if</span> ((dataTypes &amp; <span class="jde-java-font-lock-constant">MIMETYPE</span>) != <span class="jde-java-font-lock-number">0</span>) <span class="keyword">return</span> value;
              <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>
                          (&quot;<span class="string">mimetype invalid for </span>&quot; + propName);
          <span class="comment">// The following types cannot have their values validated in advance.
  </span>        <span class="comment">// The result must be validated from within the property type.
  </span>        <span class="keyword">case</span> <span class="reference">PropertyValue.FROM_PARENT</span>:
              pv = ((<span class="type">FromParent</span>)value).resolve(foNode);
              <span class="keyword">if</span> (pv == value) <span class="keyword">return</span> value;  <span class="comment">// unable to resolve
  </span>            <span class="comment">// TODO: validate here
  </span>            <span class="keyword">return</span> pv;
          <span class="keyword">case</span> <span class="reference">PropertyValue.FROM_NEAREST_SPECIFIED</span>:
              pv = ((<span class="type">FromNearestSpecified</span>)value).resolve(foNode);
              <span class="keyword">if</span> (pv == value) <span class="keyword">return</span> value;  <span class="comment">// unable to resolve
  </span>            <span class="comment">// TODO: validate here
  </span>            <span class="keyword">return</span> pv;
          <span class="keyword">case</span> <span class="reference">PropertyValue.INHERITED_VALUE</span>:
              pv = ((<span class="type">InheritedValue</span>)value).resolve(foNode);
              <span class="keyword">if</span> (pv == value) <span class="keyword">return</span> value;  <span class="comment">// unable to resolve
  </span>            <span class="comment">// TODO: validate here
  </span>            <span class="keyword">return</span> pv;
          <span class="keyword">case</span> <span class="reference">PropertyValue.LIST</span>:
              System.out.println((<span class="type">PropertyValueList</span>)value);
              <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>
                  (&quot;<span class="string">PropertyValueList passed to Property.refineParsing for </span>&quot;
                  + propName);
          <span class="keyword">default</span>:
              <span class="keyword">if</span> ( ! nested) {
                  <span class="keyword">if</span> ((dataTypes &amp; <span class="jde-java-font-lock-constant">COMPOUND</span>) != <span class="jde-java-font-lock-number">0</span>)
                      <span class="keyword">return</span> ShorthandPropSets.expandCompoundProperty
                                              (foNode.getFOTree(), value);
                  <span class="keyword">if</span> (proptype == PropertyValue.<span class="jde-java-font-lock-constant">INHERIT</span>) {
                      <span class="keyword">if</span> ((dataTypes &amp; <span class="jde-java-font-lock-constant">INHERIT</span>) != <span class="jde-java-font-lock-number">0</span>)
                          <span class="keyword">return</span> ((<span class="type">Inherit</span>)value).resolve(foNode);
                      <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>
                                      (&quot;<span class="string">'inherit' invalid for </span>&quot; + propName);
                  }
              }
              <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>
                  (&quot;<span class="string">Inappropriate dataTypes passed to Property.refineParsing: </span>&quot;
                      + value.getClass().getName());
          }
      }
  
      <span class="comment">/**
       * Refine a list of property values against their properties.
       * Expansion lists are generated by shorthand and compound expansion.
       * The set of properties will, in general, be different from the
       * generating property, which will be the one associated with the list
       * itself.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">propindex</span><span class="comment"> - the &lt;tt&gt;int&lt;/tt&gt; property index.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">foNode</span><span class="comment"> - the &lt;tt&gt;FONode&lt;/tt&gt; for which the properties are
       * being processed.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="list">list</span><span class="comment"> - the list of &lt;tt&gt;PropertyValues&lt;/tt&gt; to be refined.
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> a &lt;tt&gt;PropertyValueList&gt;/tt&gt; containing the refined property
       * values.
       */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">PropertyValueList</span> <span class="variable-name" id="refineExpansionList">refineExpansionList</span>
                          (<span class="type">int</span> <span class="variable-name">propindex</span>, <span class="type">FONode</span> <span class="variable-name">foNode</span>, <span class="type">PropertyValueList</span> <span class="variable-name">list</span>)
              <span class="keyword">throws</span> <span class="type">PropertyException</span>
      {
          <span class="keyword">if</span> (propindex != list.getProperty()) <span class="comment">// DEBUG
  </span>            <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>
                  (&quot;<span class="string">Mismatch between propindex and list property.</span>&quot;);
          <span class="type">PropertyValueList</span> <span class="variable-name" id="newlist">newlist</span> = <span class="keyword">new</span> <span class="type">PropertyValueList</span>(list.getProperty());
          <span class="type">Iterator</span> <span class="variable-name" id="properties">properties</span> = list.iterator();
          <span class="keyword">while</span> (properties.hasNext()) {
              <span class="comment">// refine the next element
  </span>            <span class="type">PropertyValue</span> <span class="variable-name">pv</span> = (<span class="type">PropertyValue</span>)(properties.next());
              pv = PropertyConsts.pconsts.refineParsing
                                              (pv.getProperty(), foNode, pv);
              <span class="comment">// if it's a list, recursively refine.  This will return a list
  </span>            <span class="keyword">if</span> (pv.getType() == PropertyValue.<span class="jde-java-font-lock-constant" id="LIST">LIST</span>) {
                  <span class="type">PropertyValueList</span> <span class="variable-name" id="pvl">pvl</span> = refineExpansionList
                          (pv.getProperty(), foNode, (<span class="type">PropertyValueList</span>)pv);
                  newlist.addAll(pvl);
              } <span class="keyword">else</span> { <span class="comment">// single element
  </span>                newlist.add(pv);
              }
          }
          <span class="keyword">return</span> newlist;
      }
  
      <span class="comment">/**
       * Determine whether argument &lt;i&gt;</span><span class="jde-java-font-lock-italic">list</span><span class="comment">&lt;/i&gt; contains a space-separated list
       * from the parser.
       * A space-separated list will be represented by a
       * &lt;tt&gt;PropertyValueList&lt;/tt&gt; as the only element of the argument
       * &lt;tt&gt;PropertyValueList&lt;/tt&gt;.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">list</span><span class="comment"> - the containing list.
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> the contained space-separated list.
       * </span><span class="jde-java-font-lock-doc-tag">@throws</span><span class="comment"> </span><span class="type">&lt;tt&gt;PropertyException&lt;/tt&gt;</span><span class="comment"> if &lt;i&gt;</span><span class="jde-java-font-lock-italic">list</span><span class="comment">&lt;/i&gt; contains more than
       * one element or if the contained element is not a list.
       */</span>
      <span class="jde-java-font-lock-modifier">protected</span> <span class="type">PropertyValueList</span> <span class="variable-name" id="spaceSeparatedList">spaceSeparatedList</span>
                                                      (<span class="type">PropertyValueList</span> <span class="variable-name">list</span>)
              <span class="keyword">throws</span> <span class="type">PropertyException</span>
      {
          <span class="keyword">if</span> (list.size() != <span class="jde-java-font-lock-number">1</span>)
                  <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>
                          (list.getClass().getName() + &quot;<span class="string"> list is not a </span>&quot;
                                  + &quot;<span class="string">single list of space-separated values</span>&quot;);
          <span class="type">PropertyValue</span> <span class="variable-name" id="val2">val2</span> = (<span class="type">PropertyValue</span>)(list.getFirst());
          <span class="keyword">if</span> ( ! (val2.getType() == PropertyValue.<span class="jde-java-font-lock-constant">LIST</span>))
                  <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>
                          (list.getClass().getName() + &quot;<span class="string"> list is not a </span>&quot;
                                  + &quot;<span class="string">single list of space-separated values</span>&quot;);
          <span class="keyword">return</span> (<span class="type">PropertyValueList</span>)val2;
      }
  
      <span class="comment">/**
       * Return the EnumType derived from the argument.
       * The argument must be an NCName whose string value is a
       * valid Enum for the property associated with the NCName.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">value</span><span class="comment"> &lt;tt&gt;PropertyValue&lt;/tt&gt;
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">property</span><span class="comment"> &lt;tt&gt;int&lt;/tt&gt; the target property index
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="type">type</span><span class="comment"> &lt;tt&gt;String&lt;/tt&gt; type of expected enum - for
       * exception messages only
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> &lt;tt&gt;EnumValue&lt;/tt&gt; equivalent of the argument
       * </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">&lt;tt&gt;PropertyException&lt;/tt&gt;
  </span><span class="comment">     */</span>
      <span class="jde-java-font-lock-modifier">protected</span> <span class="type">EnumType</span> <span class="function-name" id="getEnum">getEnum</span>(<span class="type">PropertyValue</span> <span class="variable-name">value</span>,
                                              <span class="type">int</span> <span class="variable-name">property</span>, <span class="type">String</span> <span class="variable-name">type</span>)
              <span class="keyword">throws</span> <span class="type">PropertyException</span>
      {
          <span class="keyword">if</span> (value.getType() != PropertyValue.<span class="jde-java-font-lock-constant">NCNAME</span>)
              <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>
                  (value.getClass().getName()
                                  + &quot;<span class="string"> instead of </span>&quot; + type + &quot;<span class="string"> for </span>&quot;
                                  + PropNames.getPropertyName(property));
  
          <span class="type">NCName</span> <span class="variable-name">ncname</span> = (<span class="type">NCName</span>)value;
          <span class="keyword">try</span> {
              <span class="keyword">return</span> <span class="keyword">new</span> <span class="type">EnumType</span>(property, ncname.getNCName());
          } <span class="keyword">catch</span> (<span class="type">PropertyException</span> <span class="variable-name" id="e">e</span>) {
              <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>
                          (ncname.getNCName()
                                  + &quot;<span class="string"> instead of </span>&quot; + type + &quot;<span class="string"> for </span>&quot;
                                  + PropNames.getPropertyName(property));
          }
      }
  
      <span class="comment">/**
       * Get the &lt;tt&gt;int&lt;/tt&gt; index corresponding to an enumeration keyword
       * for this property.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="enum">enum</span><span class="comment"> - a &lt;tt&gt;String&lt;/tt&gt; containing the enumeration text.
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> &lt;tt&gt;int&lt;/tt&gt; constant representing the enumeration value.
       * </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">PropertyException
  </span><span class="comment">     */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">int</span> <span class="function-name" id="getEnumIndex">getEnumIndex</span>(<span class="type">String</span> <span class="variable-name">enum</span>)
              <span class="keyword">throws</span> <span class="type">PropertyException</span>
      {
          <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(&quot;<span class="string">ENUM not supported.</span>&quot;);
      }
  
      <span class="comment">/**
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="enumIndex">enumIndex</span><span class="comment"> &lt;tt&gt;int&lt;/tt&gt; containing the enumeration index.
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> &lt;tt&gt;String&lt;/tt&gt; containing the enumeration text.
       * </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">PropertyException
  </span><span class="comment">     */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">String</span> <span class="function-name" id="getEnumText">getEnumText</span>(<span class="type">int</span> <span class="variable-name">enumIndex</span>)
                      <span class="keyword">throws</span> <span class="type">PropertyException</span>
      {
          <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(&quot;<span class="string">ENUM not supported.</span>&quot;);
      }
  
      <span class="comment">/**
       * Map the String value of an enum to its integer equivalent.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">value</span><span class="comment"> the enum text
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="values">values</span><span class="comment"> an &lt;tt&gt;ROStringArray&lt;/tt&gt; of all of the enum text values.
       * This array is effectively 1-based.
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> the integer equivalent of the enum text
       * </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">PropertyException</span><span class="comment"> if the enum text is not valid.
       */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">int</span> <span class="function-name" id="enumValueToIndex">enumValueToIndex</span>(<span class="type">String</span> <span class="variable-name">value</span>, <span class="type">String</span>[] <span class="variable-name">values</span>)
                  <span class="keyword">throws</span> <span class="type">PropertyException</span>
      {
          <span class="keyword">for</span> (<span class="type">int</span> <span class="variable-name" id="i">i</span> = <span class="jde-java-font-lock-number">1</span>; i &lt; values.length; i++) {
              <span class="keyword">if</span> (value.equals(values[i])) {
                  <span class="keyword">return</span> i;
              }
          }
          <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(&quot;<span class="string">Enum text </span>&quot; + value +&quot;<span class="string"> not found.</span>&quot;);
      }
  
      <span class="comment">/**
       * Convert an enumeration index value to a length.  This is the
       * fallback implementation of this function for properties which do not
       * support a MAPPED_LENGTH type.  Those which do must override this
       * method.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">enum</span><span class="comment"> - the &lt;tt&gt;int&lt;/tt&gt; enumeration index.
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> a &lt;tt&gt;Numeric&lt;/tt&gt;.  This implementation never returns.
       * </span><span class="jde-java-font-lock-doc-tag">@throws</span><span class="comment"> </span><span class="type">&lt;tt&gt;PropertyException&lt;/tt&gt;.
  </span><span class="comment">     */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">Numeric</span> <span class="function-name" id="getMappedLength">getMappedLength</span>(<span class="type">FONode</span> <span class="variable-name" id="node">node</span>, <span class="type">int</span> <span class="variable-name">enum</span>)
              <span class="keyword">throws</span> <span class="type">PropertyException</span>
      {
          <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>
              (&quot;<span class="string">MAPPED_LENGTH not supported.</span>&quot;);
      }
  
      <span class="comment">/**
       * Fallback getInitialValue function.  This function only handles
       * those initial value types NOT in the set USE_GET_IT_FUNCTION.  It
       * should be overriden by all properties whose initial values come from
       * that set.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">property</span><span class="comment"> &lt;tt&gt;int&lt;/tt&gt; property index
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> &lt;tt&gt;PropertyValue&lt;/tt&gt;
       * </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">&lt;tt&gt;PropertyException&lt;/tt&gt;
  </span><span class="comment">     * </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">&lt;tt&gt;PropertyNotImplementedException&lt;/tt&gt;
  </span><span class="comment">     */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">PropertyValue</span> <span class="function-name" id="getInitialValue">getInitialValue</span>(<span class="type">int</span> <span class="variable-name">property</span>)
              <span class="keyword">throws</span> <span class="type">PropertyException</span>
      {
          <span class="type">int</span> <span class="variable-name">initialValueType</span> =
                      PropertyConsts.pconsts.getInitialValueType(property);
          <span class="comment">//System.out.println(&quot;In Property getInitialValue property &quot;
  </span>                            <span class="comment">//+ property);
  </span>        <span class="keyword">if</span> ((initialValueType &amp; Property.<span class="jde-java-font-lock-constant">USE_GET_IT_FUNCTION</span>) != <span class="jde-java-font-lock-number">0</span>)
               <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>
                   (&quot;<span class="string">Property.getInitialValue() called for property with </span>&quot;
                   + &quot;<span class="string">initial value type in USE_GET_IT_FUNCTION : </span>&quot;
                   + property + &quot;<span class="string"> </span>&quot;
                   + PropNames.getPropertyName(property));
          <span class="keyword">switch</span> (initialValueType) {
          <span class="keyword">case</span> <span class="reference">NOTYPE_IT</span>:
              <span class="keyword">return</span> <span class="keyword">new</span> <span class="type">NoType</span>(property);
          <span class="keyword">case</span> <span class="reference">AUTO_IT</span>:
              <span class="keyword">return</span> <span class="keyword">new</span> <span class="type">Auto</span>(property);
          <span class="keyword">case</span> <span class="reference">NONE_IT</span>:
              <span class="keyword">return</span> <span class="keyword">new</span> <span class="type">None</span>(property);
          <span class="keyword">case</span> <span class="reference">AURAL_IT</span>:
              <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyNotImplementedException</span>
                  (&quot;<span class="string">Aural properties not implemented: </span>&quot;
                  + PropNames.getPropertyName(property));
          <span class="keyword">default</span>:
              <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>
                  (&quot;<span class="string">Unexpected initial value type </span>&quot; + initialValueType
                  + &quot;<span class="string"> for </span>&quot; + PropNames.getPropertyName(property));
          }
      }
  
      <span class="comment">/**
       * 'value' is a PropertyValueList or an individual PropertyValue.
       * If 'value' is a PropertyValueList, it must contain a single
       * PropertyValueList, which in turn contains the individual elements.
       *
       * 'value' can contain a parsed Inherit value,
       *  parsed FromParent value, parsed FromNearestSpecified value,
       *  or, in any order;
       * border-width
       *     a parsed NCName value containing a standard border width
       *     or a Numeric length value (including a percentage)
       * border-style
       *     a parsed NCName value containing a standard border style
       * border-color
       *     a parsed ColorType value, or an NCName containing one of
       *     the standard colors
       *
       * &lt;p&gt;The value(s) provided, if valid, are converted into a list
       * containing the expansion of the shorthand.  The elements may
       * be in any order.  A minimum of one value will be present.
       *
       *   a border-EDGE-color ColorType or inheritance value
       *   a border-EDGE-style EnumType or inheritance value
       *   a border-EDGE-width MappedNumeric or inheritance value
       *
       *  N.B. this is the order of elements defined in
       *       ShorthandPropSets.borderRightExpansion
       */</span>
      <span class="jde-java-font-lock-modifier">protected</span> <span class="type">PropertyValue</span> <span class="variable-name" id="borderEdge">borderEdge</span>
                          (<span class="type">int</span> <span class="variable-name">propindex</span>, <span class="type">FONode</span> <span class="variable-name">foNode</span>, <span class="type">PropertyValue</span> <span class="variable-name">value</span>,
                                  <span class="type">int</span> <span class="variable-name" id="styleProp">styleProp</span>, <span class="type">int</span> <span class="variable-name">colorProp</span>, <span class="type">int</span> <span class="variable-name">widthProp</span>)
                  <span class="keyword">throws</span> <span class="type">PropertyException</span>
      {
          <span class="keyword">return</span> borderEdge(propindex, foNode, value, styleProp,
                                              colorProp, widthProp, <span class="jde-java-font-lock-constant">NOT_NESTED</span>);
      }
  
      <span class="jde-java-font-lock-modifier">protected</span> <span class="type">PropertyValue</span> <span class="variable-name">borderEdge</span>
              (<span class="type">int</span> <span class="variable-name">propindex</span>, <span class="type">FONode</span> <span class="variable-name">foNode</span>, <span class="type">PropertyValue</span> <span class="variable-name">value</span>, <span class="type">int</span> <span class="variable-name">styleProp</span>,
                                  <span class="type">int</span> <span class="variable-name" id="colorProp">colorProp</span>, <span class="type">int</span> <span class="variable-name">widthProp</span>, <span class="type">boolean</span> <span class="variable-name">nested</span>)
                  <span class="keyword">throws</span> <span class="type">PropertyException</span>
      {
          <span class="keyword">if</span> (value.getType() != PropertyValue.<span class="jde-java-font-lock-constant">LIST</span>) {
              <span class="keyword">return</span> processEdgeValue(propindex, foNode, value,
                                      styleProp, colorProp, widthProp, nested);
          } <span class="keyword">else</span> {
              <span class="keyword">return</span> processEdgeList(propindex, foNode,
                          spaceSeparatedList((<span class="type">PropertyValueList</span>)value),
                                              styleProp, colorProp, widthProp);
          }
      }
  
      <span class="jde-java-font-lock-modifier">private</span> <span class="type">PropertyValueList</span> <span class="variable-name" id="processEdgeValue">processEdgeValue</span>
              (<span class="type">int</span> <span class="variable-name">propindex</span>, <span class="type">FONode</span> <span class="variable-name">foNode</span>, <span class="type">PropertyValue</span> <span class="variable-name">value</span>, <span class="type">int</span> <span class="variable-name">styleProp</span>,
                  <span class="type">int</span> <span class="variable-name">colorProp</span>, <span class="type">int</span> <span class="variable-name">widthProp</span>, <span class="type">boolean</span> <span class="variable-name">nested</span>)
              <span class="keyword">throws</span> <span class="type">PropertyException</span>
      {
          <span class="keyword">if</span> ( ! nested) {
              <span class="type">int</span> <span class="variable-name">type</span> = value.getType();
              <span class="keyword">if</span> (type == PropertyValue.<span class="jde-java-font-lock-constant">INHERIT</span> ||
                      type == PropertyValue.<span class="jde-java-font-lock-constant" id="FROM_PARENT">FROM_PARENT</span> ||
                          type == PropertyValue.<span class="jde-java-font-lock-constant" id="FROM_NEAREST_SPECIFIED">FROM_NEAREST_SPECIFIED</span>)
              {
                  <span class="comment">// Copy the value to each member of the shorthand expansion
  </span>                <span class="keyword">return</span> refineExpansionList(propindex, foNode,
                                  ShorthandPropSets.expandAndCopySHand(value));
              }
          }
          <span class="comment">// Make a list and pass to processList
  </span>        <span class="type">PropertyValueList</span> <span class="variable-name" id="tmpList">tmpList</span> = <span class="keyword">new</span> <span class="type">PropertyValueList</span>(propindex);
          tmpList.add(value);
          <span class="keyword">return</span> processEdgeList
                  (propindex, foNode, tmpList, styleProp, colorProp, widthProp);
      }
  
      <span class="jde-java-font-lock-modifier">private</span> <span class="type">PropertyValueList</span> <span class="variable-name" id="processEdgeList">processEdgeList</span>
              (<span class="type">int</span> <span class="variable-name">property</span>, <span class="type">FONode</span> <span class="variable-name">foNode</span>, <span class="type">PropertyValueList</span> <span class="variable-name">value</span>,
                                  <span class="type">int</span> <span class="variable-name">styleProp</span>, <span class="type">int</span> <span class="variable-name">colorProp</span>, <span class="type">int</span> <span class="variable-name">widthProp</span>)
                      <span class="keyword">throws</span> <span class="type">PropertyException</span>
      {
          <span class="comment">//int property = value.getProperty();
  </span>        <span class="type">String</span> <span class="variable-name">propName</span> = PropNames.getPropertyName(property);
          <span class="type">PropertyValue</span>   <span class="variable-name" id="color">color</span>= <span class="jde-java-font-lock-constant">null</span>,
                          style = <span class="jde-java-font-lock-constant">null</span>,
                          width = <span class="jde-java-font-lock-constant">null</span>;
  
          <span class="type">PropertyValueList</span> <span class="variable-name">newlist</span> = <span class="keyword">new</span> <span class="type">PropertyValueList</span>(property);
          <span class="comment">// This is a list
  </span>        <span class="keyword">if</span> (value.size() == <span class="jde-java-font-lock-number">0</span>)
              <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>
                              (&quot;<span class="string">Empty list for </span>&quot; + propName);
          <span class="type">Iterator</span> <span class="variable-name" id="elements">elements</span> = ((<span class="type">PropertyValueList</span>)value).iterator();
  
          <span class="reference">scanning_elements</span>: <span class="keyword">while</span> (elements.hasNext()) {
              <span class="type">PropertyValue</span> <span class="variable-name" id="pval">pval</span> = (<span class="type">PropertyValue</span>)(elements.next());
              <span class="type">int</span> <span class="variable-name">type</span> = pval.getType();
              <span class="keyword">switch</span> (type) {
              <span class="keyword">case</span> <span class="reference">PropertyValue.COLOR_TYPE</span>:
                  <span class="keyword">if</span> (color != <span class="jde-java-font-lock-constant">null</span>) MessageHandler.logln(propName +
                              &quot;<span class="string">: duplicate color overrides previous color</span>&quot;);
                  color = pval;
                  color.setProperty(colorProp);
                  <span class="keyword">continue</span> <span class="reference">scanning_elements</span>;
              <span class="keyword">case</span> <span class="reference">PropertyValue.NUMERIC</span>:
                  <span class="keyword">if</span> (width != <span class="jde-java-font-lock-constant">null</span>) MessageHandler.logln(propName +
                              &quot;<span class="string">: duplicate width overrides previous width</span>&quot;);
                  width = pval;
                  width.setProperty(widthProp);
                  <span class="keyword">continue</span> <span class="reference">scanning_elements</span>;
              <span class="keyword">case</span> <span class="reference">PropertyValue.NCNAME</span>:
                  <span class="comment">// Could be standard color, style Enum or width MappedNumeric
  </span>                <span class="type">PropertyValue</span> <span class="variable-name" id="colorFound">colorFound</span> = <span class="jde-java-font-lock-constant">null</span>;
                  <span class="type">PropertyValue</span> <span class="variable-name" id="styleFound">styleFound</span> = <span class="jde-java-font-lock-constant">null</span>;
                  <span class="type">PropertyValue</span> <span class="variable-name" id="widthFound">widthFound</span> = <span class="jde-java-font-lock-constant">null</span>;
  
                  <span class="type">String</span> <span class="variable-name">ncname</span> = ((<span class="type">NCName</span>)pval).getNCName();
                  <span class="keyword">try</span> {
                      styleFound = <span class="keyword">new</span> <span class="type">EnumType</span>(styleProp, ncname);
                  } <span class="keyword">catch</span> (<span class="type">PropertyException</span> <span class="variable-name">e</span>) {}
                  <span class="keyword">if</span> (styleFound != <span class="jde-java-font-lock-constant">null</span>) {
                      <span class="keyword">if</span> (style != <span class="jde-java-font-lock-constant">null</span>) MessageHandler.logln(propName +
                              &quot;<span class="string">: duplicate style overrides previous style</span>&quot;);
                      style = styleFound;
                      <span class="keyword">continue</span> <span class="reference">scanning_elements</span>;
                  }
  
                  <span class="keyword">try</span> {
                      widthFound =
                          (<span class="keyword">new</span> <span class="type">MappedNumeric</span>
                              (foNode, widthProp, ncname)).getMappedNumValue();
                  } <span class="keyword">catch</span> (<span class="type">PropertyException</span> <span class="variable-name">e</span>) {}
                  <span class="keyword">if</span> (widthFound != <span class="jde-java-font-lock-constant">null</span>) {
                      <span class="keyword">if</span> (width != <span class="jde-java-font-lock-constant">null</span>) MessageHandler.logln(propName +
                              &quot;<span class="string">: duplicate width overrides previous width</span>&quot;);
                      width = widthFound;
                      <span class="keyword">continue</span> <span class="reference">scanning_elements</span>;
                  }
  
                  <span class="keyword">try</span> {
                      colorFound = <span class="keyword">new</span> <span class="type">ColorType</span>(colorProp, ncname);
                  } <span class="keyword">catch</span> (<span class="type">PropertyException</span> <span class="variable-name">e</span>) {};
                  <span class="keyword">if</span> (colorFound != <span class="jde-java-font-lock-constant">null</span>) {
                      <span class="keyword">if</span> (color != <span class="jde-java-font-lock-constant">null</span>) MessageHandler.logln(propName +
                              &quot;<span class="string">: duplicate color overrides previous color</span>&quot;);
                      color = colorFound;
                      <span class="keyword">continue</span> <span class="reference">scanning_elements</span>;
                  }
  
                  <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>
                      (&quot;<span class="string">Unknown NCName value for </span>&quot; + propName + &quot;<span class="string">: </span>&quot; + ncname);
              <span class="keyword">default</span>:
                  <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>
                      (&quot;<span class="string">Invalid </span>&quot; + pval.getClass().getName() +
                          &quot;<span class="string"> property value for </span>&quot; + propName);
              } <span class="comment">// end of switch
  </span>        }
  
          <span class="comment">// Now construct the list of PropertyValues with their
  </span>        <span class="comment">// associated property indices, as expanded from the
  </span>        <span class="comment">// border-right shorthand.
  </span>        <span class="keyword">if</span> (style != <span class="jde-java-font-lock-constant">null</span>) newlist.add(style);
          <span class="keyword">if</span> (color != <span class="jde-java-font-lock-constant">null</span>) newlist.add(color);
          <span class="keyword">if</span> (width != <span class="jde-java-font-lock-constant">null</span>) newlist.add(width);
          <span class="keyword">return</span> newlist;
      }
  
  }
  </pre>
    </body>
  </html>
  
  
  
  1.1                  xml-site/targets/fop/design/alt.design/properties/PropertyParser.html
  
  Index: PropertyParser.html
  ===================================================================
  <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN">
  <!-- Created by htmlize-0.67 in css mode. -->
  <html>
    <head>
      <title>PropertyParser.java</title>
      <style type="text/css">
      <!--
        body {
          color: #000000;
          background-color: #faf0e6;
        } /* default */
        .jde-java-font-lock-number {
          color: #bc8f8f;
          background-color: #faf0e6;
        } /* jde-java-font-lock-number-face */
        .function-name {
          color: #8b2323;
          background-color: #faf0e6;
        } /* font-lock-function-name-face */
        .jde-java-font-lock-italic {
          background-color: #faf0e6;
          font-style: italic;
        } /* jde-java-font-lock-italic-face */
        .jde-java-font-lock-modifier {
          color: #da70d6;
          background-color: #faf0e6;
        } /* jde-java-font-lock-modifier-face */
        .keyword {
          color: #8b0000;
          background-color: #faf0e6;
        } /* font-lock-keyword-face */
        .variable-name {
          color: #8b008b;
          background-color: #faf0e6;
        } /* font-lock-variable-name-face */
        .string {
          color: #008b00;
          background-color: #faf0e6;
        } /* font-lock-string-face */
        .jde-java-font-lock-package {
          color: #0000cd;
          background-color: #faf0e6;
        } /* jde-java-font-lock-package-face */
        .jde-java-font-lock-constant {
          color: #5f9ea0;
          background-color: #faf0e6;
        } /* jde-java-font-lock-constant-face */
        .type {
          color: #4682b4;
          background-color: #faf0e6;
        } /* font-lock-type-face */
        .jde-java-font-lock-bold {
          background-color: #faf0e6;
          font-weight: bold;
        } /* jde-java-font-lock-bold-face */
        .jde-java-font-lock-doc-tag {
          color: #008b00;
          background-color: #faf0e6;
        } /* jde-java-font-lock-doc-tag-face */
        .comment {
          color: #00008b;
          background-color: #faf0e6;
        } /* font-lock-comment-face */
        .reference {
          color: #cd0000;
          background-color: #faf0e6;
        } /* font-lock-reference-face */
        a {
          color: inherit;
          background-color: inherit;
          font: inherit;
          text-decoration: inherit;
        }
        a:hover {
          text-decoration: underline;
        }
      -->
      </style>
    </head>
    <body>
      <pre>
  <span class="comment">/*
   * $Id: PropertyParser.html,v 1.1 2003/01/24 10:46:48 pbwest Exp $
   * Copyright (C) 2001 The Apache Software Foundation. All rights reserved.
   * For details on use and redistribution please refer to the
   * LICENSE file included with these sources.
   */</span>
  
  <span class="keyword">package</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="jde-java-font-lock-package">expr</span>;
  
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="type">PropertyConsts</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="jde-java-font-lock-package">properties</span>.<span class="type">Property</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="type">PropNames</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="type">FOTree</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="type">FONode</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="jde-java-font-lock-package">expr</span>.<span class="type">SystemFontFunction</span>;
  
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">PropertyValue</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">PropertyValueList</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">Numeric</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">Literal</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">NCName</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">Percentage</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">Ems</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">IntegerType</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">Length</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">Time</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">Frequency</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">Angle</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">Bool</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">Auto</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">None</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">Slash</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">ColorType</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">StringType</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">MimeType</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">UriType</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="jde-java-font-lock-package">indirect</span>.<span class="type">Inherit</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="jde-java-font-lock-package">indirect</span>.<span class="type">InheritedValue</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="jde-java-font-lock-package">indirect</span>.<span class="type">FromParent</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="jde-java-font-lock-package">indirect</span>.<span class="type">FromNearestSpecified</span>;
  
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">java</span>.<span class="jde-java-font-lock-package">util</span>.<span class="type">HashMap</span>;
  
  <span class="comment">/**
   * Class to parse XSL FO property expression.
   * This class is heavily based on the expression parser in James Clark's
   * XT, an XSLT processor.
   *
   * PropertyParser objects are re-usable.  The constructor simply creates the
   * object.  To parse an expression, the public method &lt;i&gt;</span><span class="jde-java-font-lock-italic">Parse</span><span class="comment">&lt;/i&gt; is
   * called.
   */</span>
  <span class="jde-java-font-lock-modifier">public</span> <span class="keyword">class</span> <span class="function-name" id="PropertyParserClass">PropertyParser</span> <span class="keyword">extends</span> <span class="type">PropertyTokenizer</span> {
  
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">String</span> <span class="variable-name" id="tag">tag</span> = &quot;<span class="string">$Name:  $</span>&quot;;
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">String</span> <span class="variable-name" id="revision">revision</span> = &quot;<span class="string">$Revision: 1.1 $</span>&quot;;
  
      <span class="comment">/** The FO tree which has initiated this parser */</span>
      <span class="jde-java-font-lock-modifier">private</span> <span class="type">FOTree</span> <span class="variable-name" id="foTree">foTree</span>;
      <span class="comment">/** The FONode which has initiated this parser */</span>
      <span class="jde-java-font-lock-modifier">private</span> <span class="type">FONode</span> <span class="variable-name" id="node">node</span>;
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="function-name" id="PropertyParser">PropertyParser</span>(<span class="type">FOTree</span> <span class="variable-name">foTree</span>) {
          <span class="keyword">super</span>();
          <span class="keyword">this</span>.foTree = foTree;
      }
  
      <span class="comment">/**
       * Parse the property expression described in the instance variables.
       * 
       * &lt;p&gt;The &lt;tt&gt;PropertyValue&lt;/tt&gt; returned by this function has the
       * following characteristics:
       * If the expression resolves to a single element that object is returned
       * directly in an object which implements &lt;PropertyValue&lt;/tt&gt;.
       *
       * &lt;p&gt;If the expression cannot be resolved into a single object, the set
       * to which it resolves is returned in a &lt;tt&gt;PropertyValueList&lt;/tt&gt; object
       * (which itself implements &lt;tt&gt;PropertyValue&lt;/tt&gt;).
       *
       * &lt;p&gt;The &lt;tt&gt;PropertyValueList&lt;/tt&gt; contains objects whose corresponding
       * elements in the original expression were separated by &lt;em&gt;</span><span class="jde-java-font-lock-italic">commas</span><span class="comment">&lt;/em&gt;.
       *
       * &lt;p&gt;Objects whose corresponding elements in the original expression
       * were separated by spaces are composed into a sublist contained in
       * another &lt;tt&gt;PropertyValueList&lt;/tt&gt;.  If all of the elements in the
       * expression were separated by spaces, the returned
       * &lt;tt&gt;PropertyValueList&lt;/tt&gt; will contain one element, a
       * &lt;tt&gt;PropertyValueList&lt;/tt&gt; containing objects representing each of
       * the space-separated elements in the original expression.
       *
       * &lt;p&gt;E.g., if a &lt;b&gt;</span><span class="jde-java-font-lock-bold">font-family</span><span class="comment">&lt;/b&gt; property is assigned the string
       * &lt;em&gt;</span><span class="jde-java-font-lock-italic">Palatino, New Century Schoolbook, serif</span><span class="comment">&lt;/em&gt;, the returned value
       * will look like this:
       * &lt;pre&gt;
       * PropertyValueList(NCName('Palatino')
       *                   PropertyValueList(NCName('New')
       *                                     NCName('Century')
       *                                     NCName('Schoolbook') )
       *                   NCName('serif') )
       * &lt;/pre&gt;
       * &lt;p&gt;If the property had been assigned the string
       * &lt;em&gt;</span><span class="jde-java-font-lock-italic">Palatino, &quot;New Century Schoolbook&quot;, serif</span><span class="comment">&lt;/em&gt;, the returned value
       * would look like this:
       * &lt;pre&gt;
       * PropertyValueList(NCName('Palatino')
       *                   NCName('New Century Schoolbook')
       *                   NCName('serif') )
       * &lt;/pre&gt;
       * &lt;p&gt;If a &lt;b&gt;</span><span class="jde-java-font-lock-bold">background-position</span><span class="comment">&lt;/b&gt; property is assigned the string
       * &lt;em&gt;</span><span class="jde-java-font-lock-italic">top center</span><span class="comment">&lt;/em&gt;, the returned value will look like this:
       * &lt;pre&gt;
       * PropertyValueList(PropertyValueList(NCName('top')
       *                                     NCName('center') ) )
       * &lt;/pre&gt;
       *
       * &lt;p&gt;Note: If the property expression String is empty, a StringProperty
       * object holding an empty String is returned.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">node</span><span class="comment"> - the &lt;tt&gt;FONode&lt;/tt&gt; for which the property expression
       * is being resolved.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="property">property</span><span class="comment"> - an &lt;tt&gt;int&lt;/tt&gt; containing the property index.
       * which the property expression is to be evaluated.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="expr">expr</span><span class="comment"> - the specified value (attribute on the xml element).
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> a PropertyValue holding the parsed result.
       * </span><span class="jde-java-font-lock-doc-tag">@throws</span><span class="comment"> </span><span class="type">PropertyException</span><span class="comment"> if the &quot;expr&quot; cannot be parsed as a
       * PropertyValue.
       */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">PropertyValue</span> <span class="function-name" id="parse">parse</span>(<span class="type">FONode</span> <span class="variable-name">node</span>, <span class="type">int</span> <span class="variable-name">property</span>, <span class="type">String</span> <span class="variable-name">expr</span>)
          <span class="keyword">throws</span> <span class="type">PropertyException</span>
      {
          <span class="comment">//System.out.println(&quot;-----Entering parse:&quot;
  </span>        <span class="comment">// + PropNames.getPropertyName(property) + &quot; &quot; + expr);
  </span>        <span class="jde-java-font-lock-modifier">synchronized</span> (<span class="keyword">this</span>) {
              <span class="comment">// make sure this parser is available
  </span>            <span class="keyword">if</span> (getExpr() != <span class="jde-java-font-lock-constant" id="null">null</span>) <span class="comment">// the parser is currently active
  </span>                <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>
                          (&quot;<span class="string">PropertyParser is currently active: </span>&quot; + getExpr());
              initialize(property, expr);
              <span class="keyword">this</span>.node = node;
          }
  
          next();
          <span class="keyword">if</span> (currentToken == <span class="jde-java-font-lock-constant" id="EOF">EOF</span>)
              <span class="comment">// prop value is empty
  </span>            <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>
                      (&quot;<span class="string">No token recognized in :</span>&quot; + expr + &quot;<span class="string">:</span>&quot;);
  
          <span class="type">PropertyValueList</span> <span class="variable-name" id="propList">propList</span> = <span class="keyword">new</span> <span class="type">PropertyValueList</span>(property);
          <span class="keyword">while</span> (<span class="jde-java-font-lock-constant" id="true">true</span>) {
              <span class="type">PropertyValue</span> <span class="variable-name" id="prop">prop</span> = parseAdditiveExpr();
              <span class="keyword">if</span> (currentToken == <span class="jde-java-font-lock-constant">EOF</span>) {
                  <span class="comment">// end of the expression - add to list and go
  </span>                <span class="keyword">if</span> (propList.size() != <span class="jde-java-font-lock-number">0</span>) {
                      propList.add(prop);
                      reset();
                      <span class="keyword">return</span> propList;
                  } <span class="keyword">else</span> { <span class="comment">// list is empty
  </span>                    reset();
                      <span class="keyword">return</span> prop;
                  }
              }
              <span class="comment">// throw away commas separating arguments.  These can occur
  </span>            <span class="comment">// in font-family and voice-family.  Commas are regarded here
  </span>            <span class="comment">// as separators of list and sublist elements.
  </span>            <span class="comment">// See 7.16.5 &quot;text-shadow&quot; in the 1.0 Recommendation for an
  </span>            <span class="comment">// example of sublists.
  </span>            <span class="keyword">if</span> (currentToken == <span class="jde-java-font-lock-constant" id="COMMA">COMMA</span>) {
                  next();
                  propList.add(prop);
              } <span class="keyword">else</span> { <span class="comment">// whitespace separates list elements; make a sublist
  </span>                propList.add(parseSublist(prop));
                  <span class="keyword">if</span> (currentToken == <span class="jde-java-font-lock-constant">EOF</span>) {
                      reset();
                      <span class="keyword">return</span> propList;
                  }
              }
          }
      }
  
      <span class="comment">/**
       * &lt;p&gt;Parse a property values sublist - a list of whitespace separated
       * &lt;tt&gt;PropertyValue&lt;/tt&gt;s.
       * &lt;p&gt;
       * Property value expressions for various properties may contain lists
       * of values, which may be separated by whitespace or by commas.  See,
       * e.g., 7.6.17 &quot;voice-family&quot; and 7.8.2 &quot;font-family&quot;.  The shorthands
       * may also contain lists of elements, generally (or exclusively)
       * whitespace separated.  7.16.5 &quot;text-shadow&quot; allows whitespace
       * separated length doubles or triples to be specified for individual
       * shadow effects, with multiple shadow effects, each separated by
       * commmas.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="initialValue">initialValue</span><span class="comment"> a &lt;tt&gt;PropertyValue&lt;/tt&gt; to assign as the initial
       * value of the sublist.  The detection of this value, which is
       * whitespace separated from a subsequent value,  has been the
       * trigger for the creation of the sublist.
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> a &lt;tt&gt;PropertyValueList&lt;/tt&gt; containing the sublist.  The
       * indicatior for the end of the sublist is the end of the expression,
       * or a comma.
       */</span>
      <span class="type">PropertyValueList</span> <span class="function-name" id="parseSublist">parseSublist</span>(<span class="type">PropertyValue</span> <span class="variable-name">initialValue</span>)
          <span class="keyword">throws</span> <span class="type">PropertyException</span>
      {
          <span class="type">PropertyValueList</span> <span class="variable-name" id="sublist">sublist</span> = <span class="keyword">new</span> <span class="type">PropertyValueList</span>(property);
          sublist.add(initialValue);
          <span class="keyword">while</span> (<span class="jde-java-font-lock-constant">true</span>) {
              <span class="type">PropertyValue</span> <span class="variable-name">prop</span> = parseAdditiveExpr();
              <span class="keyword">if</span> (currentToken == <span class="jde-java-font-lock-constant">EOF</span>) {
                  <span class="comment">// end of the expression - add to sublist and go
  </span>                sublist.add(prop);
                  <span class="keyword">return</span> sublist;
              }
              <span class="comment">// Comma separates next element - end of sublist
  </span>            <span class="keyword">if</span> (currentToken == <span class="jde-java-font-lock-constant">COMMA</span>) {
                  next();
                  sublist.add(prop);
                  <span class="keyword">return</span> sublist;
              } <span class="keyword">else</span> { <span class="comment">// whitespace separates next elements; add to sublist
  </span>                sublist.add(prop);
              }
          }
      }
  
      <span class="comment">/**
       * Reset the parser by resetting the tokenizer to null (or equivalent)
       * values.
       */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">void</span> <span class="function-name" id="resetParser">resetParser</span>() {
          <span class="jde-java-font-lock-modifier">synchronized</span> (<span class="keyword">this</span>) {
              <span class="comment">//elementsSeen = 0;
  </span>            <span class="comment">//restrictedValueFunctSeen = null;
  </span>            reset();
          }
      }
  
      <span class="comment">/**
       * Generate an arithmetic error string.
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> arithmetic error message.
       */</span>
      <span class="jde-java-font-lock-modifier">private</span> <span class="type">String</span> <span class="function-name" id="arithErrorStr">arithErrorStr</span>() {
          <span class="keyword">return</span> &quot;<span class="string">Arithmetic operator not followed by Numeric or integer: </span>&quot;
                  + getExpr();
      }
  
  
      <span class="comment">/**
       * Generate an function numeric argument error string.
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> function numeric argument error message.
       */</span>
      <span class="jde-java-font-lock-modifier">private</span> <span class="type">String</span> <span class="function-name" id="funcNumericErrorStr">funcNumericErrorStr</span>() {
          <span class="keyword">return</span> &quot;<span class="string">Function requires Numeric or integer argument: </span>&quot;
                  + getExpr();
      }
  
      <span class="comment">/**
       * Try to parse an addition or subtraction expression and return the
       * resulting PropertyValue.
       */</span>
      <span class="jde-java-font-lock-modifier">private</span> <span class="type">PropertyValue</span> <span class="function-name" id="parseAdditiveExpr">parseAdditiveExpr</span>() <span class="keyword">throws</span> <span class="type">PropertyException</span> {
          <span class="comment">// Evaluate and put result on the operand stack
  </span>        <span class="comment">//System.out.println(&quot;parseAdd&quot;);
  </span>        <span class="type">PropertyValue</span> <span class="variable-name">prop</span> = parseMultiplicativeExpr();
          <span class="type">PropertyValue</span> <span class="variable-name" id="pv">pv</span>;
          <span class="reference">outer</span>:
          <span class="keyword">for</span> (; ; ) {
              <span class="reference">inner</span>:
              <span class="keyword">switch</span> (prop.getType()) {
              <span class="keyword">case</span> <span class="reference">PropertyValue.NUMERIC</span>: {
                  <span class="keyword">switch</span> (currentToken) {
                  <span class="keyword">case</span> <span class="reference">PLUS</span>:
                      next();
                      pv = parseMultiplicativeExpr();
                      <span class="keyword">switch</span> (pv.getType()) {
                      <span class="keyword">case</span> <span class="reference">PropertyValue.NUMERIC</span>:
                          ((<span class="type">Numeric</span>)prop).add((<span class="type">Numeric</span>)pv);
                          <span class="keyword">break</span> <span class="reference">inner</span>;
                      <span class="keyword">case</span> <span class="reference">PropertyValue.INTEGER</span>:
                          ((<span class="type">Numeric</span>)prop).add((<span class="type">double</span>)
                                              (((<span class="type">IntegerType</span>)pv).getInt()));
                          <span class="keyword">break</span> <span class="reference">inner</span>;
                      <span class="keyword">default</span>:
                          <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(arithErrorStr());
                      }
                  <span class="keyword">case</span> <span class="reference">MINUS</span>:
                      next();
                      pv = parseMultiplicativeExpr();
                      <span class="keyword">switch</span> (pv.getType()) {
                      <span class="keyword">case</span> <span class="reference">PropertyValue.NUMERIC</span>:
                          ((<span class="type">Numeric</span>)prop).subtract((<span class="type">Numeric</span>)pv);
                          <span class="keyword">break</span> <span class="reference">inner</span>;
                      <span class="keyword">case</span> <span class="reference">PropertyValue.INTEGER</span>:
                          ((<span class="type">Numeric</span>)prop).subtract((<span class="type">double</span>)
                                               (((<span class="type">IntegerType</span>)pv).getInt()));
                          <span class="keyword">break</span> <span class="reference">inner</span>;
                      <span class="keyword">default</span>:
                          <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(arithErrorStr());
                      }
                  <span class="keyword">default</span>:
                      <span class="keyword">break</span> <span class="reference">outer</span>;
                  }
              }
              <span class="keyword">case</span> <span class="reference">PropertyValue.INTEGER</span>: {
                  <span class="type">int</span> <span class="variable-name" id="intVal">intVal</span> = ((<span class="type">IntegerType</span>)prop).getInt();
                  <span class="keyword">switch</span> (currentToken) {
                  <span class="keyword">case</span> <span class="reference">PLUS</span>:
                      next();
                      pv = parseMultiplicativeExpr();
                      <span class="keyword">switch</span> (pv.getType()) {
                      <span class="keyword">case</span> <span class="reference">PropertyValue.NUMERIC</span>:
                          prop = ((<span class="type">Numeric</span>)pv).add((<span class="type">double</span>)intVal);
                          <span class="keyword">break</span> <span class="reference">inner</span>;
                      <span class="keyword">case</span> <span class="reference">PropertyValue.INTEGER</span>:
                          ((<span class="type">IntegerType</span>)prop).setInt(intVal +
                                              ((<span class="type">IntegerType</span>)pv).getInt());
                          <span class="keyword">break</span> <span class="reference">inner</span>;
                      <span class="keyword">default</span>:
                          <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(arithErrorStr());
                      }
                  <span class="keyword">case</span> <span class="reference">MINUS</span>:
                      next();
                      pv = parseMultiplicativeExpr();
                      <span class="keyword">switch</span> (pv.getType()) {
                      <span class="keyword">case</span> <span class="reference">PropertyValue.NUMERIC</span>:
                          ((<span class="type">Numeric</span>)pv).add((<span class="type">double</span>)(-intVal));
                          prop = ((<span class="type">Numeric</span>)pv).negate();
                          <span class="keyword">break</span> <span class="reference">inner</span>;
                      <span class="keyword">case</span> <span class="reference">PropertyValue.INTEGER</span>:
                          ((<span class="type">IntegerType</span>)prop).setInt(intVal +
                                              ((<span class="type">IntegerType</span>)pv).getInt());
                          <span class="keyword">break</span> <span class="reference">inner</span>;
                      <span class="keyword">default</span>:
                          <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(arithErrorStr());
                      }
                  <span class="keyword">default</span>:
                      <span class="keyword">break</span> <span class="reference">outer</span>;
                  }
              }
              <span class="keyword">default</span>:
                  <span class="keyword">break</span> <span class="reference">outer</span>;
              }
          }
          <span class="keyword">return</span> prop;
      }
  
      <span class="comment">/**
       * Try to parse a multiply, divide or modulo expression and return
       * the resulting PropertyValue.
       */</span>
      <span class="jde-java-font-lock-modifier">private</span> <span class="type">PropertyValue</span> <span class="function-name" id="parseMultiplicativeExpr">parseMultiplicativeExpr</span>() <span class="keyword">throws</span> <span class="type">PropertyException</span> {
          <span class="comment">//System.out.println(&quot;parseMult&quot;);
  </span>        <span class="type">PropertyValue</span> <span class="variable-name">prop</span> = parseUnaryExpr();
          <span class="type">PropertyValue</span> <span class="variable-name">pv</span>;
          <span class="reference">outer</span>:
          <span class="comment">// Outer loop exists to handle a sequence of multiplicative operations
  </span>        <span class="comment">// e.g. 5 * 4 / 2
  </span>        <span class="comment">// break outer; will terminate the multiplicative expression parsing
  </span>        <span class="comment">// break inner; will look for another trailing multiplicative
  </span>        <span class="comment">// operator.
  </span>        <span class="keyword">for</span> (; ; ) {
              <span class="reference">inner</span>:
              <span class="keyword">switch</span> (prop.getType()) {
              <span class="keyword">case</span> <span class="reference">PropertyValue.NUMERIC</span>:
                  <span class="keyword">switch</span> (currentToken) {
                  <span class="keyword">case</span> <span class="reference">DIV</span>:
                      next();
                      pv = parseUnaryExpr();
                      <span class="keyword">switch</span> (pv.getType()) {
                      <span class="keyword">case</span> <span class="reference">PropertyValue.INTEGER</span>:
                          ((<span class="type">Numeric</span>)prop).divide
                                          ((<span class="type">double</span>)(((<span class="type">IntegerType</span>)pv).getInt()));
                          <span class="keyword">break</span> <span class="reference">inner</span>;
                      <span class="keyword">case</span> <span class="reference">PropertyValue.NUMERIC</span>:
                          ((<span class="type">Numeric</span>)prop).divide((<span class="type">Numeric</span>)pv);
                          <span class="keyword">break</span> <span class="reference">inner</span>;
                      <span class="keyword">default</span>:
                          <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(arithErrorStr());
                      }
                  <span class="keyword">case</span> <span class="reference">MOD</span>:
                      next();
                      pv = parseUnaryExpr();
                      <span class="keyword">switch</span> (pv.getType()) {
                      <span class="keyword">case</span> <span class="reference">PropertyValue.INTEGER</span>:
                          ((<span class="type">Numeric</span>)prop).mod
                                          ((<span class="type">double</span>)(((<span class="type">IntegerType</span>)pv).getInt()));
                          <span class="keyword">break</span> <span class="reference">inner</span>;
                      <span class="keyword">case</span> <span class="reference">PropertyValue.NUMERIC</span>:
                          ((<span class="type">Numeric</span>)prop).mod((<span class="type">Numeric</span>)pv);
                          <span class="keyword">break</span> <span class="reference">inner</span>;
                      <span class="keyword">default</span>:
                          <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(arithErrorStr());
                      }
                  <span class="keyword">case</span> <span class="reference">MULTIPLY</span>:
                      next();
                      pv = parseUnaryExpr();
                      <span class="keyword">switch</span> (pv.getType()) {
                      <span class="keyword">case</span> <span class="reference">PropertyValue.INTEGER</span>:
                          ((<span class="type">Numeric</span>)prop).multiply
                                          ((<span class="type">double</span>)(((<span class="type">IntegerType</span>)pv).getInt()));
                          <span class="keyword">break</span> <span class="reference">inner</span>;
                      <span class="keyword">case</span> <span class="reference">PropertyValue.NUMERIC</span>:
                          ((<span class="type">Numeric</span>)prop).multiply((<span class="type">Numeric</span>)pv);
                          <span class="keyword">break</span> <span class="reference">inner</span>;
                      <span class="keyword">default</span>:
                          <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(arithErrorStr());
                      }
                  <span class="keyword">default</span>:
                      <span class="keyword">break</span> <span class="reference">outer</span>;
                  }
                  <span class="comment">// N.B. The above case cannot fall through to here
  </span>            <span class="keyword">case</span> <span class="reference">PropertyValue.INTEGER</span>:
                  <span class="comment">// This code treats all multiplicative operations as implicit
  </span>                <span class="comment">// operations on doubles.  It might be reasonable to allow
  </span>                <span class="comment">// an integer multiply.
  </span>                <span class="type">int</span> <span class="variable-name">intVal</span> = ((<span class="type">IntegerType</span>)prop).getInt();
                  <span class="keyword">switch</span> (currentToken) {
                  <span class="keyword">case</span> <span class="reference">DIV</span>:
                      next();
                      pv = parseUnaryExpr();
                      <span class="keyword">switch</span> (pv.getType()) {
                      <span class="keyword">case</span> <span class="reference">PropertyValue.INTEGER</span>:
                          prop = <span class="keyword">new</span> <span class="type">Numeric</span>(property,
                              (<span class="type">double</span>)intVal / ((<span class="type">IntegerType</span>)pv).getInt());
                          <span class="keyword">break</span> <span class="reference">inner</span>;
                      <span class="keyword">case</span> <span class="reference">PropertyValue.NUMERIC</span>:
                          prop = (<span class="keyword">new</span> <span class="type">Numeric</span>(property, (<span class="type">double</span>)intVal))
                                                          .divide((<span class="type">Numeric</span>)pv);
                          <span class="keyword">break</span> <span class="reference">inner</span>;
                      <span class="keyword">default</span>:
                          <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(arithErrorStr());
                      }
                  <span class="keyword">case</span> <span class="reference">MOD</span>:
                      next();
                      pv = parseUnaryExpr();
                      <span class="keyword">switch</span> (pv.getType()) {
                      <span class="keyword">case</span> <span class="reference">PropertyValue.INTEGER</span>:
                          prop = <span class="keyword">new</span> <span class="type">Numeric</span>(property,
                                  ((<span class="type">double</span>)intVal) % ((<span class="type">IntegerType</span>)pv).getInt());
                          <span class="keyword">break</span> <span class="reference">inner</span>;
                      <span class="keyword">case</span> <span class="reference">PropertyValue.NUMERIC</span>:
                          prop = (<span class="keyword">new</span> <span class="type">Numeric</span>(property, (<span class="type">double</span>)intVal))
                                                          .mod((<span class="type">Numeric</span>)pv);
                          <span class="keyword">break</span> <span class="reference">inner</span>;
                      <span class="keyword">default</span>:
                          <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(arithErrorStr());
                      }
                  <span class="keyword">case</span> <span class="reference">MULTIPLY</span>:
                      next();
                      pv = parseUnaryExpr();
                      <span class="keyword">switch</span> (pv.getType()) {
                      <span class="keyword">case</span> <span class="reference">PropertyValue.INTEGER</span>:
                          prop = <span class="keyword">new</span> <span class="type">Numeric</span>(property,
                              ((<span class="type">double</span>)intVal) * ((<span class="type">IntegerType</span>)pv).getInt());
                          <span class="keyword">break</span> <span class="reference">inner</span>;
                      <span class="keyword">case</span> <span class="reference">PropertyValue.NUMERIC</span>:
                          prop = (<span class="keyword">new</span> <span class="type">Numeric</span>(property, (<span class="type">double</span>)intVal))
                                                     .multiply((<span class="type">Numeric</span>)pv);
                          <span class="keyword">break</span> <span class="reference">inner</span>;
                      <span class="keyword">default</span>:
                          <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(arithErrorStr());
                      }
                  <span class="keyword">default</span>:
                      <span class="keyword">break</span> <span class="reference">outer</span>;
                  }
              <span class="keyword">default</span>:
                  <span class="keyword">break</span> <span class="reference">outer</span>;
              }
          }
          <span class="keyword">return</span> prop;
      }
  
      <span class="comment">/**
       * Try to parse a unary minus expression and return the
       * resulting PropertyValue.
       */</span>
      <span class="jde-java-font-lock-modifier">private</span> <span class="type">PropertyValue</span> <span class="function-name" id="parseUnaryExpr">parseUnaryExpr</span>() <span class="keyword">throws</span> <span class="type">PropertyException</span> {
          <span class="comment">//System.out.println(&quot;Unary entry&quot;);
  </span>        <span class="keyword">if</span> (currentToken == <span class="jde-java-font-lock-constant" id="MINUS">MINUS</span>) {
              next();
              <span class="type">PropertyValue</span> <span class="variable-name">pv</span> = parseUnaryExpr();
              <span class="keyword">switch</span> (pv.getType()) {
              <span class="keyword">case</span> <span class="reference">PropertyValue.NUMERIC</span>:
                  <span class="keyword">return</span> ((<span class="type">Numeric</span>)pv).negate();
              <span class="keyword">case</span> <span class="reference">PropertyValue.INTEGER</span>:
                  ((<span class="type">IntegerType</span>)pv).setInt( -((<span class="type">IntegerType</span>)pv).getInt());
                  <span class="keyword">return</span> pv;
              <span class="keyword">default</span>:
                  <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(arithErrorStr());
              }
          }
          <span class="keyword">return</span> parsePrimaryExpr();
      }
  
  
      <span class="comment">/**
       * Checks that the current token is a right parenthesis
       * and throws an exception if this isn't the case.
       */</span>
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">void</span> <span class="function-name" id="expectRpar">expectRpar</span>() <span class="keyword">throws</span> <span class="type">PropertyException</span> {
          <span class="keyword">if</span> (currentToken != <span class="jde-java-font-lock-constant" id="RPAR">RPAR</span>)
              <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(&quot;<span class="string">expected )</span>&quot;);
          next();
      }
  
      <span class="comment">/**
       * Try to parse a primary expression and return the
       * resulting PropertyValue.
       * A primary expression is either a parenthesized expression or an
       * expression representing a primitive PropertyValue datatype, such as a
       * string literal, an NCname, a number or a unit expression, or a
       * function call expression.
       */</span>
      <span class="jde-java-font-lock-modifier">private</span> <span class="type">PropertyValue</span> <span class="function-name" id="parsePrimaryExpr">parsePrimaryExpr</span>() <span class="keyword">throws</span> <span class="type">PropertyException</span> {
          <span class="type">PropertyValue</span> <span class="variable-name">prop</span>;
          <span class="comment">//System.out.println(&quot;Primary currentToken:&quot; + currentToken + &quot; &quot;
  </span>        <span class="comment">//                   + currentTokenValue);
  </span>        <span class="keyword">switch</span> (currentToken) {
          <span class="keyword">case</span> <span class="reference">LPAR</span>:
              next();
              prop = parseAdditiveExpr();
              expectRpar();
              <span class="comment">// Do this here, rather than breaking, because expectRpar()
  </span>            <span class="comment">// consumes the right parenthesis and calls next().
  </span>            <span class="keyword">return</span> prop;
  
          <span class="keyword">case</span> <span class="reference">LITERAL</span>:
              prop = <span class="keyword">new</span> <span class="type">Literal</span>(property, currentTokenValue);
              <span class="keyword">break</span>;
  
          <span class="keyword">case</span> <span class="reference">NCNAME</span>:
              <span class="comment">// Interpret this in context of the property or do it later?
  </span>            prop = <span class="keyword">new</span> <span class="type">NCName</span>(property, currentTokenValue);
              <span class="keyword">break</span>;
  
          <span class="keyword">case</span> <span class="reference">FLOAT</span>:
              <span class="comment">// Do I need to differentiate here between floats and integers?
  </span>            prop = <span class="keyword">new</span> <span class="type">Numeric</span>
                      (property, Double.parseDouble(currentTokenValue));
              <span class="keyword">break</span>;
  
          <span class="keyword">case</span> <span class="reference">INTEGER</span>:
              prop = <span class="keyword">new</span> <span class="type">IntegerType</span>
                      (property, Integer.parseInt(currentTokenValue));
              <span class="keyword">break</span>;
  
          <span class="keyword">case</span> <span class="reference">PERCENT</span>:
              <span class="comment">/*
               * Generate a Percentage object with the percentage number.
               * The constructor converts this to a straight multiplicative
               * factor by dividing by 100.
               */</span>
              prop = Percentage.makePercentage
                      (property, Double.parseDouble(currentTokenValue));
              <span class="keyword">break</span>;
  
          <span class="keyword">case</span> <span class="reference">ABSOLUTE_LENGTH</span>:
              prop = Length.makeLength(property,
                                Double.parseDouble(currentTokenValue),
                                currentUnit);
              <span class="keyword">break</span>;
          <span class="keyword">case</span> <span class="reference">TIME</span>:
              prop = <span class="keyword">new</span> <span class="type">Time</span>(property, currentUnit,
                              Double.parseDouble(currentTokenValue));
              <span class="keyword">break</span>;
          <span class="keyword">case</span> <span class="reference">FREQ</span>:
              prop = <span class="keyword">new</span> <span class="type">Frequency</span>(property, currentUnit,
                                   Double.parseDouble(currentTokenValue));
              <span class="keyword">break</span>;
          <span class="keyword">case</span> <span class="reference">ANGLE</span>:
              prop = <span class="keyword">new</span> <span class="type">Angle</span>(property, currentUnit,
                               Double.parseDouble(currentTokenValue));
              <span class="keyword">break</span>;
          <span class="keyword">case</span> <span class="reference">RELATIVE_LENGTH</span>:
              prop = Ems.makeEms(node, property,
                                 Double.parseDouble(currentTokenValue));
              <span class="keyword">break</span>;
  
          <span class="keyword">case</span> <span class="reference">COLORSPEC</span>:
              prop = <span class="keyword">new</span> <span class="type">ColorType</span>(property, currentTokenValue);
              <span class="keyword">break</span>;
  
          <span class="keyword">case</span> <span class="reference">BOOL</span>:
              prop = <span class="keyword">new</span> <span class="type">Bool</span>(property, currentTokenValue);
              <span class="keyword">break</span>;
  
          <span class="keyword">case</span> <span class="reference">AUTO</span>:
              prop = <span class="keyword">new</span> <span class="type">Auto</span>(property);
              <span class="keyword">break</span>;
  
          <span class="keyword">case</span> <span class="reference">NONE</span>:
              prop = <span class="keyword">new</span> <span class="type">None</span>(property);
              <span class="keyword">break</span>;
  
          <span class="keyword">case</span> <span class="reference">INHERIT</span>:
              prop = <span class="keyword">new</span> <span class="type">Inherit</span>(property);
              <span class="comment">//throw new PropertyException(&quot;INHERIT not supported&quot;);
  </span>            <span class="keyword">break</span>;
  
          <span class="keyword">case</span> <span class="reference">URI</span>:
              prop = <span class="keyword">new</span> <span class="type">UriType</span>(property, currentTokenValue);
              <span class="keyword">break</span>;
  
          <span class="keyword">case</span> <span class="reference">MIMETYPE</span>:
              prop = <span class="keyword">new</span> <span class="type">MimeType</span>(property, currentTokenValue);
              <span class="keyword">break</span>;
  
          <span class="keyword">case</span> <span class="reference">SLASH</span>:
              prop = <span class="keyword">new</span> <span class="type">Slash</span>(property);
              <span class="keyword">break</span>;
  
          <span class="keyword">case</span> <span class="reference">FUNCTION_LPAR</span>: {
              <span class="comment">// N.B. parseArgs() invokes expectRpar at the end of argument
  </span>            <span class="comment">// processing, so, like LPAR processing, next() is not called
  </span>            <span class="comment">// and the return from this method must be premature
  </span>            prop = <span class="jde-java-font-lock-constant">null</span>;
              <span class="type">int</span> <span class="variable-name" id="funcType">funcType</span> = PropertyValue.<span class="jde-java-font-lock-constant" id="NO_TYPE">NO_TYPE</span>;
              <span class="type">String</span> <span class="variable-name" id="function">function</span> = currentTokenValue;
              next();
              <span class="keyword">do</span> {
                  <span class="comment">// Numeric functions
  </span>                <span class="keyword">if</span> (function.equals(&quot;<span class="string">floor</span>&quot;)) {
                      <span class="type">PropertyValue</span>[] <span class="variable-name" id="args">args</span> = parseArgs(<span class="jde-java-font-lock-number">1</span>);
                      <span class="keyword">switch</span> (args[<span class="jde-java-font-lock-number">0</span>].getType()) {
                      <span class="keyword">case</span> <span class="reference">PropertyValue.INTEGER</span>:
                          args[<span class="jde-java-font-lock-number">0</span>] =
                              <span class="keyword">new</span> <span class="type">Numeric</span>
                                  (property, ((<span class="type">IntegerType</span>)args[<span class="jde-java-font-lock-number">0</span>]).getInt());
                      <span class="keyword">case</span> <span class="reference">PropertyValue.NUMERIC</span>:
                          prop = <span class="keyword">new</span> <span class="type">Numeric</span>
                                  (property, ((<span class="type">Numeric</span>)args[<span class="jde-java-font-lock-number">0</span>]).floor());
                          <span class="keyword">break</span>;
                      <span class="keyword">default</span>:
                          <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(funcNumericErrorStr());
                      }
                      <span class="keyword">break</span>;
                  }
                  <span class="keyword">if</span> (function.equals(&quot;<span class="string">ceiling</span>&quot;)) {
                      <span class="type">PropertyValue</span>[] <span class="variable-name">args</span> = parseArgs(<span class="jde-java-font-lock-number">1</span>);
                      <span class="keyword">switch</span> (args[<span class="jde-java-font-lock-number">0</span>].getType()) {
                      <span class="keyword">case</span> <span class="reference">PropertyValue.INTEGER</span>:
                          args[<span class="jde-java-font-lock-number">0</span>] =
                              <span class="keyword">new</span> <span class="type">Numeric</span>
                                  (property, ((<span class="type">IntegerType</span>)args[<span class="jde-java-font-lock-number">0</span>]).getInt());
                      <span class="keyword">case</span> <span class="reference">PropertyValue.NUMERIC</span>:
                          prop = <span class="keyword">new</span> <span class="type">Numeric</span>
                                  (property, ((<span class="type">Numeric</span>)args[<span class="jde-java-font-lock-number">0</span>]).ceiling());
                          <span class="keyword">break</span>;
                      <span class="keyword">default</span>:
                          <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(funcNumericErrorStr());
                      }
                      <span class="keyword">break</span>;
                  }
                  <span class="keyword">if</span> (function.equals(&quot;<span class="string">round</span>&quot;)) {
                      <span class="type">PropertyValue</span>[] <span class="variable-name">args</span> = parseArgs(<span class="jde-java-font-lock-number">1</span>);
                      <span class="keyword">switch</span> (args[<span class="jde-java-font-lock-number">0</span>].getType()) {
                      <span class="keyword">case</span> <span class="reference">PropertyValue.INTEGER</span>:
                          args[<span class="jde-java-font-lock-number">0</span>] =
                              <span class="keyword">new</span> <span class="type">Numeric</span>
                                  (property, ((<span class="type">IntegerType</span>)args[<span class="jde-java-font-lock-number">0</span>]).getInt());
                      <span class="keyword">case</span> <span class="reference">PropertyValue.NUMERIC</span>:
                          prop = <span class="keyword">new</span> <span class="type">Numeric</span>
                                  (property, ((<span class="type">Numeric</span>)args[<span class="jde-java-font-lock-number">0</span>]).round());
                          <span class="keyword">break</span>;
                      <span class="keyword">default</span>:
                          <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(funcNumericErrorStr());
                      }
                      <span class="keyword">break</span>;
                  }
                  <span class="keyword">if</span> (function.equals(&quot;<span class="string">min</span>&quot;)) {
                      <span class="type">PropertyValue</span>[] <span class="variable-name">args</span> = parseArgs(<span class="jde-java-font-lock-number">2</span>);
                      <span class="keyword">switch</span> (args[<span class="jde-java-font-lock-number">0</span>].getType()) {
                      <span class="keyword">case</span> <span class="reference">PropertyValue.INTEGER</span>:
                          args[<span class="jde-java-font-lock-number">0</span>] =
                              <span class="keyword">new</span> <span class="type">Numeric</span>
                                  (property, ((<span class="type">IntegerType</span>)args[<span class="jde-java-font-lock-number">0</span>]).getInt());
                      <span class="keyword">case</span> <span class="reference">PropertyValue.NUMERIC</span>:
                          prop = ((<span class="type">Numeric</span>)args[<span class="jde-java-font-lock-number">0</span>]).min((<span class="type">Numeric</span>)args[<span class="jde-java-font-lock-number">1</span>]);
                          <span class="keyword">break</span>;
                      <span class="keyword">default</span>:
                          <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(funcNumericErrorStr());
                      }
                      <span class="keyword">break</span>;
                  }
                  <span class="keyword">if</span> (function.equals(&quot;<span class="string">max</span>&quot;)) {
                      <span class="type">PropertyValue</span>[] <span class="variable-name">args</span> = parseArgs(<span class="jde-java-font-lock-number">2</span>);
                      <span class="keyword">switch</span> (args[<span class="jde-java-font-lock-number">0</span>].getType()) {
                      <span class="keyword">case</span> <span class="reference">PropertyValue.INTEGER</span>:
                          args[<span class="jde-java-font-lock-number">0</span>] =
                              <span class="keyword">new</span> <span class="type">Numeric</span>
                                  (property, ((<span class="type">IntegerType</span>)args[<span class="jde-java-font-lock-number">0</span>]).getInt());
                      <span class="keyword">case</span> <span class="reference">PropertyValue.NUMERIC</span>:
                          prop = ((<span class="type">Numeric</span>)args[<span class="jde-java-font-lock-number">0</span>]).max((<span class="type">Numeric</span>)args[<span class="jde-java-font-lock-number">1</span>]);
                          <span class="keyword">break</span>;
                      <span class="keyword">default</span>:
                          <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(funcNumericErrorStr());
                      }
                      <span class="keyword">break</span>;
                  }
                  <span class="keyword">if</span> (function.equals(&quot;<span class="string">abs</span>&quot;)) {
                      <span class="type">PropertyValue</span>[] <span class="variable-name">args</span> = parseArgs(<span class="jde-java-font-lock-number">1</span>);
                      <span class="keyword">switch</span> (args[<span class="jde-java-font-lock-number">0</span>].getType()) {
                      <span class="keyword">case</span> <span class="reference">PropertyValue.INTEGER</span>:
                          args[<span class="jde-java-font-lock-number">0</span>] =
                              <span class="keyword">new</span> <span class="type">Numeric</span>
                                  (property, ((<span class="type">IntegerType</span>)args[<span class="jde-java-font-lock-number">0</span>]).getInt());
                      <span class="keyword">case</span> <span class="reference">PropertyValue.NUMERIC</span>:
                          prop = ((<span class="type">Numeric</span>)args[<span class="jde-java-font-lock-number">0</span>]).abs();
                          <span class="keyword">break</span>;
                      <span class="keyword">default</span>:
                          <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(funcNumericErrorStr());
                      }
                      <span class="keyword">break</span>;
                  }
  
                  <span class="comment">// Color functions
  </span>                <span class="keyword">if</span> (function.equals(&quot;<span class="string">rgb</span>&quot;)) {
                      <span class="comment">// Currently arguments must all be integers.
  </span>                    <span class="type">PropertyValue</span>[] <span class="variable-name">args</span> = parseArgs(<span class="jde-java-font-lock-number">3</span>);
                      <span class="keyword">switch</span> (args[<span class="jde-java-font-lock-number">0</span>].getType()) {
                      <span class="keyword">case</span> <span class="reference">PropertyValue.INTEGER</span>:
                          prop = <span class="keyword">new</span> <span class="type">ColorType</span>
                                  (property, ((<span class="type">IntegerType</span>)args[<span class="jde-java-font-lock-number">0</span>]).getInt(),
                                   ((<span class="type">IntegerType</span>)args[<span class="jde-java-font-lock-number">1</span>]).getInt(),
                                   ((<span class="type">IntegerType</span>)args[<span class="jde-java-font-lock-number">2</span>]).getInt());
                          <span class="keyword">break</span>;
                      <span class="keyword">case</span> <span class="reference">PropertyValue.NUMERIC</span>:
                          prop = <span class="keyword">new</span> <span class="type">ColorType</span>
                                  (property, ((<span class="type">Numeric</span>)args[<span class="jde-java-font-lock-number">0</span>]).asInt(),
                                   ((<span class="type">Numeric</span>)args[<span class="jde-java-font-lock-number">1</span>]).asInt(),
                                   ((<span class="type">Numeric</span>)args[<span class="jde-java-font-lock-number">2</span>]).asInt());
                          <span class="keyword">break</span>;
                      <span class="keyword">default</span>:
                          <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(funcNumericErrorStr());
                      }
                      <span class="keyword">break</span>;
                  }
                  <span class="keyword">if</span> (function.equals(&quot;<span class="string">rgb-icc</span>&quot;)) {
                      <span class="type">PropertyValue</span>[] <span class="variable-name">args</span> = parseArgs(<span class="jde-java-font-lock-number">6</span>);
                      <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">FunctionNotImplementedException</span>(&quot;<span class="string">rgb-icc</span>&quot;);
                      <span class="comment">//break;
  </span>                }
                  <span class="keyword">if</span> (function.equals(&quot;<span class="string">system-color</span>&quot;)) {
                      <span class="type">PropertyValue</span>[] <span class="variable-name">args</span> = parseArgs(<span class="jde-java-font-lock-number">1</span>);
                      prop = <span class="keyword">new</span> <span class="type">ColorType</span>
                              (property, ((<span class="type">StringType</span>)args[<span class="jde-java-font-lock-number">0</span>]).getString());
                      <span class="keyword">break</span>;
                  }
  
                  <span class="comment">// Font function
  </span>                <span class="keyword">if</span> (function.equals(&quot;<span class="string">system-font</span>&quot;)) {
                      <span class="type">PropertyValue</span>[] <span class="variable-name">args</span> = parseArgs(<span class="jde-java-font-lock-number">1</span>, <span class="jde-java-font-lock-number">2</span>);
                      <span class="keyword">if</span> (args.length == <span class="jde-java-font-lock-number">1</span>) {
                          prop = SystemFontFunction.systemFontCharacteristic
                                  (property,
                                   ((<span class="type">StringType</span>)args[<span class="jde-java-font-lock-number">0</span>]).getString());
                      } <span class="keyword">else</span> {
                          <span class="comment">// 2 args
  </span>                        prop = SystemFontFunction.systemFontCharacteristic
                                  (property,
                                   ((<span class="type">StringType</span>)args[<span class="jde-java-font-lock-number">0</span>]).getString(),
                                   ((<span class="type">StringType</span>)args[<span class="jde-java-font-lock-number">1</span>]).getString());
                      }
                      <span class="keyword">break</span>;
                  }
  
                  <span class="comment">// Property value functions
  </span>                <span class="keyword">if</span> (function.equals(&quot;<span class="string">label-end</span>&quot;)) {
                      <span class="type">PropertyValue</span>[] <span class="variable-name">args</span> = parseArgs(<span class="jde-java-font-lock-number">0</span>);
                      <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">FunctionNotImplementedException</span>(&quot;<span class="string">label-end</span>&quot;);
                      <span class="comment">//break;
  </span>                }
                  <span class="keyword">if</span> (function.equals(&quot;<span class="string">body-start</span>&quot;)) {
                      <span class="type">PropertyValue</span>[] <span class="variable-name">args</span> = parseArgs(<span class="jde-java-font-lock-number">0</span>);
                      <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">FunctionNotImplementedException</span>(&quot;<span class="string">body-start</span>&quot;);
                      <span class="comment">//break;
  </span>                }
                  <span class="keyword">if</span> (function.equals(&quot;<span class="string">inherited-property-value</span>&quot;)) {
                      <span class="type">int</span> <span class="variable-name" id="propindex">propindex</span> = property;
                      <span class="type">PropertyValue</span>[] <span class="variable-name">args</span> = parseArgs(<span class="jde-java-font-lock-number">0</span>, <span class="jde-java-font-lock-number">1</span>);
                      <span class="keyword">if</span> (args.length != <span class="jde-java-font-lock-number">0</span>)
                          propindex = PropNames.getPropertyIndex(
                                  ((<span class="type">StringType</span>)args[<span class="jde-java-font-lock-number">0</span>]).getString());
  
                      <span class="comment">// If it's a compound, return an InheritedValue object
  </span>                    <span class="keyword">if</span> (PropertyConsts.pconsts.isCompound(propindex)) {
                          prop = <span class="keyword">new</span> <span class="type">InheritedValue</span>(property, propindex);
                          <span class="keyword">break</span>;
                      }
                      <span class="comment">// Is it an inherited property?
  </span>                    <span class="keyword">if</span> (PropertyConsts.pconsts.inheritance(propindex)
                                                              == Property.<span class="jde-java-font-lock-constant" id="NO">NO</span>)
                          <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>
                                  (&quot;<span class="string">inherited-property-value: </span>&quot;
                                   + PropNames.getPropertyName(propindex)
                                   + &quot;<span class="string"> is not inherited.</span>&quot;);
                      <span class="comment">// Not a compound, and inherited - try to resolve it
  </span>                    prop = node.fromParent(property, propindex);
                      <span class="keyword">break</span>;
                  }
                  <span class="comment">// N.B. see comments on classes FromNearestSpecified and
  </span>                <span class="comment">// FromParent for explanation of this section
  </span>                <span class="keyword">if</span> (function.equals(&quot;<span class="string">from-parent</span>&quot;))
                      funcType = PropertyValue.<span class="jde-java-font-lock-constant" id="FROM_PARENT">FROM_PARENT</span>;
                  <span class="keyword">if</span> (function.equals(&quot;<span class="string">from-nearest-specified-value</span>&quot;))
                      funcType = PropertyValue.<span class="jde-java-font-lock-constant" id="FROM_NEAREST_SPECIFIED">FROM_NEAREST_SPECIFIED</span>;
                  <span class="keyword">if</span> (funcType == <span class="reference">PropertyValue</span>.<span class="type">FROM_PARENT</span>
                      || funcType == PropertyValue.<span class="jde-java-font-lock-constant">FROM_NEAREST_SPECIFIED</span>)
                  {
                      <span class="comment">// Preset the return value in case of a shorthand property
  </span>                    <span class="keyword">switch</span> (funcType) {
                      <span class="keyword">case</span> <span class="reference">PropertyValue.FROM_PARENT</span>:
                          prop = <span class="keyword">new</span> <span class="type">FromParent</span>(property);
                      <span class="keyword">case</span> <span class="reference">PropertyValue.FROM_NEAREST_SPECIFIED</span>:
                          prop = <span class="keyword">new</span> <span class="type">FromNearestSpecified</span>(property);
                      }
  
                      <span class="type">PropertyValue</span>[] <span class="variable-name">args</span> = parseArgs(<span class="jde-java-font-lock-number">0</span>, <span class="jde-java-font-lock-number">1</span>);
                      <span class="keyword">if</span> (args.length == <span class="jde-java-font-lock-number">0</span>) {
                          <span class="keyword">if</span> (! (PropertyConsts.pconsts.isShorthand(property)
                             || PropertyConsts.pconsts.isCompound(property))) {
                              <span class="comment">// develop the function value and return it as
  </span>                            <span class="comment">// a property.
  </span>                            <span class="keyword">switch</span> (funcType) {
                              <span class="keyword">case</span> <span class="reference">PropertyValue.FROM_PARENT</span>:
                                  prop = node.fromParent(property);
                              <span class="keyword">case</span> <span class="reference">PropertyValue.FROM_NEAREST_SPECIFIED</span>:
                                  prop = node.fromNearestSpecified(property);
                              }
                          }
                          <span class="comment">// else a shorthand/compound - do nothing;
  </span>                        <span class="comment">// prop has been
  </span>                        <span class="comment">// set to the appropriate pseudo-propertyValue
  </span>                    } <span class="keyword">else</span> { <span class="comment">// one argument - it must be a property name
  </span>                        <span class="keyword">if</span> ( ! (args[<span class="jde-java-font-lock-number">0</span>] <span class="keyword">instanceof</span> <span class="type">NCName</span>))
                              <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>
                                      (function + &quot;<span class="string"> function requires</span>&quot;
                                       + &quot;<span class="string"> property name arg.</span>&quot;);
                          <span class="comment">// else arg[0] is an NCName
  </span>                        <span class="type">NCName</span> <span class="variable-name" id="ncname">ncname</span> = (<span class="type">NCName</span>)args[<span class="jde-java-font-lock-number">0</span>];
                          <span class="type">String</span> <span class="variable-name" id="propname">propname</span> = ncname.getNCName();
                          <span class="type">int</span> <span class="variable-name" id="nameindex">nameindex</span> =
                                  PropNames.getPropertyIndex(propname);
                          <span class="keyword">if</span> (PropertyConsts.pconsts.isShorthand(nameindex)
                              || PropertyConsts.pconsts.isCompound(nameindex)) {
                              <span class="comment">// the argument is a shorthand/compound property -
  </span>                            <span class="comment">// it must be the same as the property being
  </span>                            <span class="comment">// assigned to.
  </span>                            <span class="comment">// see 5.10.4 Property Value Functions
  </span>                            <span class="keyword">if</span> ( ! (nameindex == property))
                                  <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>
                                          (function +
                                           &quot;<span class="string"> argument </span>&quot; + propname +
                                           &quot;<span class="string"> does not match property </span>&quot; +
                                           PropNames.getPropertyName(property));
                              <span class="comment">// else perform shorthand/compound processing
  </span>                            <span class="comment">// i.e. do nothing;
  </span>                            <span class="comment">// prop has been set to the correct
  </span>                            <span class="comment">// pseudo-propertyValue
  </span>                        }
                          <span class="keyword">else</span> {   <span class="comment">// An NCName but not a shorthand/compound
  </span>                            <span class="comment">// Perform normal from-? processing
  </span>                            <span class="keyword">switch</span> (funcType) {
                              <span class="keyword">case</span> <span class="reference">PropertyValue.FROM_PARENT</span>:
                                  prop = node.fromParent(property, nameindex);
                              <span class="keyword">case</span> <span class="reference">PropertyValue.FROM_NEAREST_SPECIFIED</span>:
                                  prop = node.fromNearestSpecified
                                                          (property, nameindex);
                              }
                          }
                      }
                      <span class="keyword">break</span>;
                  }
                  <span class="keyword">if</span> (function.equals(&quot;<span class="string">from-table-column</span>&quot;)) {
                      <span class="type">PropertyValue</span>[] <span class="variable-name">args</span> = parseArgs(<span class="jde-java-font-lock-number">0</span>, <span class="jde-java-font-lock-number">1</span>);
                      <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">FunctionNotImplementedException</span>
                              (&quot;<span class="string">from-table-column</span>&quot;);
                      <span class="comment">//break;
  </span>                }
                  <span class="keyword">if</span> (function.equals(&quot;<span class="string">proportional-column-width</span>&quot;)) {
                      <span class="type">PropertyValue</span>[] <span class="variable-name">args</span> = parseArgs(<span class="jde-java-font-lock-number">1</span>);
                      <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">FunctionNotImplementedException</span>
                              (&quot;<span class="string">proportional-column-width</span>&quot;);
                      <span class="comment">//break;
  </span>                }
                  <span class="keyword">if</span> (function.equals(&quot;<span class="string">merge-property-values</span>&quot;)) {
                      <span class="type">PropertyValue</span>[] <span class="variable-name">args</span> = parseArgs(<span class="jde-java-font-lock-number">0</span>, <span class="jde-java-font-lock-number">1</span>);
                      <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">FunctionNotImplementedException</span>
                              (&quot;<span class="string">merge-property-values</span>&quot;);
                      <span class="comment">//break;
  </span>                }
                  <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(&quot;<span class="string">no such function: </span>&quot;
                                                          + function);
              } <span class="keyword">while</span> (<span class="jde-java-font-lock-constant" id="false">false</span>);
              <span class="keyword">return</span> prop;
          }
          <span class="keyword">default</span>:
              <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(&quot;<span class="string">syntax error</span>&quot;);
          }
          next();
          <span class="keyword">return</span> prop;
      }
  
      <span class="comment">/**
       * Parse a comma separated list of function arguments. Each argument
       * may itself be an expression. This method consumes the closing right
       * parenthesis of the argument list.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="nbArgs">nbArgs</span><span class="comment"> The number of arguments expected by the function.
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> &lt;tt&gt;PropertyValueList&lt;/tt&gt; of &lt;tt&gt;PropertyValue&lt;/tt&gt; objects
       * representing the arguments found.
       * </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">PropertyException
  </span><span class="comment">     */</span>
      <span class="type">PropertyValue</span>[] <span class="function-name" id="parseArgs">parseArgs</span>(<span class="type">int</span> <span class="variable-name">nbArgs</span>) <span class="keyword">throws</span> <span class="type">PropertyException</span> {
          <span class="keyword">return</span> parseArgs(nbArgs, nbArgs);
      }
  
      <span class="comment">/**
       * Parse a comma separated list of function arguments. Each argument
       * may itself be an expression. This method consumes the closing right
       * parenthesis of the argument list.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="minArgs">minArgs</span><span class="comment"> The minimum number of arguments expected by the function.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="maxArgs">maxArgs</span><span class="comment"> The maximum number of arguments expected by the function.
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> &lt;tt&gt;PropertyValueList&lt;/tt&gt; of &lt;tt&gt;PropertyValue&lt;/tt&gt; objects
       * representing the arguments found.  N.B.  The actual number of arguments
       * returned is guaranteed to be between minArgs and maxArgs, inclusive,
       * but the actual list of args found is terminated by the end of the
       * array, or the first null element.
       * </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">PropertyException
  </span><span class="comment">     */</span>
      <span class="type">PropertyValue</span>[] <span class="function-name">parseArgs</span>(<span class="type">int</span> <span class="variable-name">minArgs</span>, <span class="type">int</span> <span class="variable-name">maxArgs</span>)
          <span class="keyword">throws</span> <span class="type">PropertyException</span>
      {
          <span class="type">PropertyValue</span>[] <span class="variable-name">args</span> = <span class="keyword">new</span> <span class="type">PropertyValue</span>[maxArgs];
          <span class="type">PropertyValue</span> <span class="variable-name">prop</span>;
          <span class="type">int</span> <span class="variable-name" id="i">i</span> = <span class="jde-java-font-lock-number">0</span>;
          <span class="keyword">if</span> (currentToken == <span class="jde-java-font-lock-constant">RPAR</span>) {
              <span class="comment">// No args: func()
  </span>            next();
          } <span class="keyword">else</span> {
              <span class="keyword">while</span> (<span class="jde-java-font-lock-constant">true</span>) {
                  prop = parseAdditiveExpr();
                  <span class="keyword">if</span> (i &lt; maxArgs) {
                      args[i++] = prop;
                  }
                  <span class="comment">// ignore extra args
  </span>                <span class="keyword">if</span> (currentToken != <span class="jde-java-font-lock-constant">COMMA</span>)
                      <span class="keyword">break</span>;
                  next();
              }
              expectRpar();
          }
          <span class="keyword">if</span> (minArgs &gt; i || i &gt; maxArgs) {
              <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(&quot;<span class="string">Wrong number of args for function</span>&quot;);
          }
          <span class="keyword">return</span> args;
      }
  
  }
  </pre>
    </body>
  </html>
  
  
  
  1.1                  xml-site/targets/fop/design/alt.design/properties/PropertySets.html
  
  Index: PropertySets.html
  ===================================================================
  <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN">
  <!-- Created by htmlize-0.67 in css mode. -->
  <html>
    <head>
      <title>PropertySets.java</title>
      <style type="text/css">
      <!--
        body {
          color: #000000;
          background-color: #faf0e6;
        } /* default */
        .jde-java-font-lock-modifier {
          color: #da70d6;
          background-color: #faf0e6;
        } /* jde-java-font-lock-modifier-face */
        .keyword {
          color: #8b0000;
          background-color: #faf0e6;
        } /* font-lock-keyword-face */
        .jde-java-font-lock-link {
          color: #0000ff;
          background-color: #faf0e6;
          text-decoration: underline;
        } /* jde-java-font-lock-link-face */
        .variable-name {
          color: #8b008b;
          background-color: #faf0e6;
        } /* font-lock-variable-name-face */
        .string {
          color: #008b00;
          background-color: #faf0e6;
        } /* font-lock-string-face */
        .jde-java-font-lock-package {
          color: #0000cd;
          background-color: #faf0e6;
        } /* jde-java-font-lock-package-face */
        .jde-java-font-lock-constant {
          color: #5f9ea0;
          background-color: #faf0e6;
        } /* jde-java-font-lock-constant-face */
        .type {
          color: #4682b4;
          background-color: #faf0e6;
        } /* font-lock-type-face */
        .jde-java-font-lock-bold {
          background-color: #faf0e6;
          font-weight: bold;
        } /* jde-java-font-lock-bold-face */
        .jde-java-font-lock-doc-tag {
          color: #008b00;
          background-color: #faf0e6;
        } /* jde-java-font-lock-doc-tag-face */
        .comment {
          color: #00008b;
          background-color: #faf0e6;
        } /* font-lock-comment-face */
        .function-name {
          color: #8b2323;
          background-color: #faf0e6;
        } /* font-lock-function-name-face */
        a {
          color: inherit;
          background-color: inherit;
          font: inherit;
          text-decoration: inherit;
        }
        a:hover {
          text-decoration: underline;
        }
      -->
      </style>
    </head>
    <body>
      <pre>
  <span class="comment">/**
   * $Id: PropertySets.html,v 1.1 2003/01/24 10:46:48 pbwest Exp $
   * &lt;br/&gt;Copyright (C) 2001 The Apache Software Foundation. All rights reserved.
   * &lt;br/&gt;For details on use and redistribution please refer to the
   * &lt;br/&gt;LICENSE file included with these sources.
   *
   * </span><span class="jde-java-font-lock-doc-tag">@author</span><span class="comment"> &lt;a href=&quot;mailto:pbwest@powerup.com.au&quot;&gt;</span><span class="jde-java-font-lock-link">Peter B. West</span><span class="comment">&lt;/a&gt;
   * </span><span class="jde-java-font-lock-doc-tag">@version</span><span class="comment"> $Revision: 1.1 $ $Name:  $
   */</span>
  
  <span class="keyword">package</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>;
  
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">java</span>.<span class="jde-java-font-lock-package">util</span>.<span class="type">BitSet</span>;
  
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="type">PropNames</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datastructs</span>.<span class="type">ROBitSet</span>;
  
  <span class="comment">/**
   * This class contains &lt;tt&gt;ROBitSet&lt;/tt&gt;s which encode the various sets of
   * properties which are defined to apply to each of the Flow Objects.  These 
   * &lt;tt&gt;ROBitSet&lt;/tt&gt;s provide a convenient means of specifying the
   * relationship between FOs and properties.
   */</span>
  <span class="jde-java-font-lock-modifier">public</span> <span class="keyword">class</span> <span class="function-name" id="PropertySetsClass">PropertySets</span> {
  
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">String</span> <span class="variable-name" id="tag">tag</span> = &quot;<span class="string">$Name:  $</span>&quot;;
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">String</span> <span class="variable-name" id="revision">revision</span> = &quot;<span class="string">$Revision: 1.1 $</span>&quot;;
  
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">String</span> <span class="variable-name" id="packageName">packageName</span> = &quot;<span class="string">org.apache.fop.fo</span>&quot;;
  
      <span class="comment">/**
       * &lt;tt&gt;BitSet&lt;/tt&gt; of the &lt;tt&gt;Integer&lt;/tt&gt; objects corresponding to the
       * constant index of each property in the set of
       * &lt;b&gt;</span><span class="jde-java-font-lock-bold">Common Accessibility Properties</span><span class="comment">&lt;/b&gt;.
       */</span>
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">BitSet</span> <span class="variable-name" id="accessibilityProps">accessibilityProps</span> = <span class="keyword">new</span> <span class="type">BitSet</span>();
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROBitSet</span> <span class="variable-name" id="accessibilitySet">accessibilitySet</span>;
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="type">BitSet</span> <span class="function-name" id="accessibilitySetClone">accessibilitySetClone</span>() {
          <span class="keyword">return</span> (<span class="type">BitSet</span>)(accessibilityProps.clone());
      }
  
      <span class="jde-java-font-lock-modifier">static</span> {
           accessibilityProps.set(PropNames.<span class="jde-java-font-lock-constant" id="ROLE">ROLE</span>);       
           accessibilityProps.set(PropNames.<span class="jde-java-font-lock-constant" id="SOURCE_DOCUMENT">SOURCE_DOCUMENT</span>);
           accessibilitySet = <span class="keyword">new</span> <span class="type">ROBitSet</span>(accessibilityProps);
      }
      <span class="comment">/**
       * &lt;tt&gt;BitSet&lt;/tt&gt; of the &lt;tt&gt;Integer&lt;/tt&gt; objects corresponding to the
       * constant index of each property in the set of
       * &lt;b&gt;</span><span class="jde-java-font-lock-bold">Common Absolute Position Properties</span><span class="comment">&lt;/b&gt;.
       */</span>
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">BitSet</span> <span class="variable-name" id="absolutePositionProps">absolutePositionProps</span> = <span class="keyword">new</span> <span class="type">BitSet</span>();
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROBitSet</span> <span class="variable-name" id="absolutePositionSet">absolutePositionSet</span>;
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="type">BitSet</span> <span class="function-name" id="absolutePositionSetClone">absolutePositionSetClone</span>() {
          <span class="keyword">return</span> (<span class="type">BitSet</span>)(absolutePositionProps.clone());
      }
  
      <span class="jde-java-font-lock-modifier">static</span> {
          absolutePositionProps.set(PropNames.<span class="jde-java-font-lock-constant" id="ABSOLUTE_POSITION">ABSOLUTE_POSITION</span>);
          absolutePositionProps.set(PropNames.<span class="jde-java-font-lock-constant" id="BOTTOM">BOTTOM</span>);
          absolutePositionProps.set(PropNames.<span class="jde-java-font-lock-constant" id="LEFT">LEFT</span>);
          absolutePositionProps.set(PropNames.<span class="jde-java-font-lock-constant" id="RIGHT">RIGHT</span>);
          absolutePositionProps.set(PropNames.<span class="jde-java-font-lock-constant" id="TOP">TOP</span>);
          absolutePositionSet = <span class="keyword">new</span> <span class="type">ROBitSet</span>(absolutePositionProps);
      }
      <span class="comment">/**
       * &lt;tt&gt;BitSet&lt;/tt&gt; of the &lt;tt&gt;Integer&lt;/tt&gt; objects corresponding to the
       * constant index of each property in the set of
       * &lt;b&gt;</span><span class="jde-java-font-lock-bold">Common Aural Properties</span><span class="comment">&lt;/b&gt;.
       */</span>
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">BitSet</span> <span class="variable-name" id="auralProps">auralProps</span> = <span class="keyword">new</span> <span class="type">BitSet</span>();
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROBitSet</span> <span class="variable-name" id="auralSet">auralSet</span>;
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="type">BitSet</span> <span class="function-name" id="auralSetClone">auralSetClone</span>() {
          <span class="keyword">return</span> (<span class="type">BitSet</span>)(auralProps.clone());
      }
  
      <span class="jde-java-font-lock-modifier">static</span> {
          auralProps.set(PropNames.<span class="jde-java-font-lock-constant" id="AZIMUTH">AZIMUTH</span>);
          auralProps.set(PropNames.<span class="jde-java-font-lock-constant" id="CUE_AFTER">CUE_AFTER</span>);
          auralProps.set(PropNames.<span class="jde-java-font-lock-constant" id="CUE_BEFORE">CUE_BEFORE</span>);
          auralProps.set(PropNames.<span class="jde-java-font-lock-constant" id="ELEVATION">ELEVATION</span>);
          auralProps.set(PropNames.<span class="jde-java-font-lock-constant" id="PAUSE_AFTER">PAUSE_AFTER</span>);
          auralProps.set(PropNames.<span class="jde-java-font-lock-constant" id="PAUSE_BEFORE">PAUSE_BEFORE</span>);
          auralProps.set(PropNames.<span class="jde-java-font-lock-constant" id="PITCH">PITCH</span>);
          auralProps.set(PropNames.<span class="jde-java-font-lock-constant" id="PITCH_RANGE">PITCH_RANGE</span>);
          auralProps.set(PropNames.<span class="jde-java-font-lock-constant" id="PLAY_DURING">PLAY_DURING</span>);
          auralProps.set(PropNames.<span class="jde-java-font-lock-constant" id="RICHNESS">RICHNESS</span>);
          auralProps.set(PropNames.<span class="jde-java-font-lock-constant" id="SPEAK">SPEAK</span>);
          auralProps.set(PropNames.<span class="jde-java-font-lock-constant" id="SPEAK_HEADER">SPEAK_HEADER</span>);
          auralProps.set(PropNames.<span class="jde-java-font-lock-constant" id="SPEAK_NUMERAL">SPEAK_NUMERAL</span>);
          auralProps.set(PropNames.<span class="jde-java-font-lock-constant" id="SPEAK_PUNCTUATION">SPEAK_PUNCTUATION</span>);
          auralProps.set(PropNames.<span class="jde-java-font-lock-constant" id="SPEECH_RATE">SPEECH_RATE</span>);
          auralProps.set(PropNames.<span class="jde-java-font-lock-constant" id="STRESS">STRESS</span>);
          auralProps.set(PropNames.<span class="jde-java-font-lock-constant" id="VOICE_FAMILY">VOICE_FAMILY</span>);
          auralProps.set(PropNames.<span class="jde-java-font-lock-constant" id="VOLUME">VOLUME</span>);
          auralSet = <span class="keyword">new</span> <span class="type">ROBitSet</span>(auralProps);
      }
      <span class="comment">/**
       * &lt;tt&gt;BitSet&lt;/tt&gt; of the &lt;tt&gt;Integer&lt;/tt&gt; objects corresponding to the
       * constant index of each property in the set of
       * &lt;b&gt;</span><span class="jde-java-font-lock-bold">Common Background Properties</span><span class="comment">&lt;/b&gt;.
       */</span>
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">BitSet</span> <span class="variable-name" id="backgroundProps">backgroundProps</span> = <span class="keyword">new</span> <span class="type">BitSet</span>();
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROBitSet</span> <span class="variable-name" id="backgroundSet">backgroundSet</span>;
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="type">BitSet</span> <span class="function-name" id="backgroundSetClone">backgroundSetClone</span>() {
          <span class="keyword">return</span> (<span class="type">BitSet</span>)(backgroundProps.clone());
      }
  
      <span class="jde-java-font-lock-modifier">static</span> {
          backgroundProps.set(PropNames.<span class="jde-java-font-lock-constant" id="BACKGROUND">BACKGROUND</span>);
          backgroundProps.set(PropNames.<span class="jde-java-font-lock-constant" id="BACKGROUND_ATTACHMENT">BACKGROUND_ATTACHMENT</span>);
          backgroundProps.set(PropNames.<span class="jde-java-font-lock-constant" id="BACKGROUND_COLOR">BACKGROUND_COLOR</span>);
          backgroundProps.set(PropNames.<span class="jde-java-font-lock-constant" id="BACKGROUND_IMAGE">BACKGROUND_IMAGE</span>);
          backgroundProps.set(PropNames.<span class="jde-java-font-lock-constant" id="BACKGROUND_POSITION">BACKGROUND_POSITION</span>);
          backgroundProps.set(PropNames.<span class="jde-java-font-lock-constant" id="BACKGROUND_POSITION_HORIZONTAL">BACKGROUND_POSITION_HORIZONTAL</span>);
          backgroundProps.set(PropNames.<span class="jde-java-font-lock-constant" id="BACKGROUND_POSITION_VERTICAL">BACKGROUND_POSITION_VERTICAL</span>);
          backgroundProps.set(PropNames.<span class="jde-java-font-lock-constant" id="BACKGROUND_REPEAT">BACKGROUND_REPEAT</span>);
          backgroundSet = <span class="keyword">new</span> <span class="type">ROBitSet</span>(backgroundProps);
      }
      <span class="comment">/**
       * &lt;tt&gt;BitSet&lt;/tt&gt; of the &lt;tt&gt;Integer&lt;/tt&gt; objects corresponding to the
       * constant index of each property in the set of
       * &lt;b&gt;</span><span class="jde-java-font-lock-bold">Common Border Properties</span><span class="comment">&lt;/b&gt;.
       */</span>
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">BitSet</span> <span class="variable-name" id="borderProps">borderProps</span> = <span class="keyword">new</span> <span class="type">BitSet</span>();
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROBitSet</span> <span class="variable-name" id="borderSet">borderSet</span>;
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="type">BitSet</span> <span class="function-name" id="borderSetClone">borderSetClone</span>() {
          <span class="keyword">return</span> (<span class="type">BitSet</span>)(borderProps.clone());
      }
  
      <span class="jde-java-font-lock-modifier">static</span> {
          borderProps.set(PropNames.<span class="jde-java-font-lock-constant" id="BORDER">BORDER</span>);
          borderProps.set(PropNames.<span class="jde-java-font-lock-constant" id="BORDER_AFTER_COLOR">BORDER_AFTER_COLOR</span>);
          borderProps.set(PropNames.<span class="jde-java-font-lock-constant" id="BORDER_AFTER_STYLE">BORDER_AFTER_STYLE</span>);
          borderProps.set(PropNames.<span class="jde-java-font-lock-constant" id="BORDER_AFTER_WIDTH">BORDER_AFTER_WIDTH</span>);
          borderProps.set(PropNames.<span class="jde-java-font-lock-constant" id="BORDER_AFTER_WIDTH_LENGTH">BORDER_AFTER_WIDTH_LENGTH</span>);
          borderProps.set(PropNames.<span class="jde-java-font-lock-constant" id="BORDER_AFTER_WIDTH_CONDITIONALITY">BORDER_AFTER_WIDTH_CONDITIONALITY</span>);
          borderProps.set(PropNames.<span class="jde-java-font-lock-constant" id="BORDER_BEFORE_COLOR">BORDER_BEFORE_COLOR</span>);
          borderProps.set(PropNames.<span class="jde-java-font-lock-constant" id="BORDER_BEFORE_STYLE">BORDER_BEFORE_STYLE</span>);
          borderProps.set(PropNames.<span class="jde-java-font-lock-constant" id="BORDER_BEFORE_WIDTH">BORDER_BEFORE_WIDTH</span>);
          borderProps.set(PropNames.<span class="jde-java-font-lock-constant" id="BORDER_BEFORE_WIDTH_LENGTH">BORDER_BEFORE_WIDTH_LENGTH</span>);
          borderProps.set(PropNames.<span class="jde-java-font-lock-constant" id="BORDER_BEFORE_WIDTH_CONDITIONALITY">BORDER_BEFORE_WIDTH_CONDITIONALITY</span>);
          borderProps.set(PropNames.<span class="jde-java-font-lock-constant" id="BORDER_BOTTOM">BORDER_BOTTOM</span>);
          borderProps.set(PropNames.<span class="jde-java-font-lock-constant" id="BORDER_BOTTOM_COLOR">BORDER_BOTTOM_COLOR</span>);
          borderProps.set(PropNames.<span class="jde-java-font-lock-constant" id="BORDER_BOTTOM_STYLE">BORDER_BOTTOM_STYLE</span>);
          borderProps.set(PropNames.<span class="jde-java-font-lock-constant" id="BORDER_BOTTOM_WIDTH">BORDER_BOTTOM_WIDTH</span>);
          borderProps.set(PropNames.<span class="jde-java-font-lock-constant" id="BORDER_COLOR">BORDER_COLOR</span>);
          borderProps.set(PropNames.<span class="jde-java-font-lock-constant" id="BORDER_END_COLOR">BORDER_END_COLOR</span>);
          borderProps.set(PropNames.<span class="jde-java-font-lock-constant" id="BORDER_END_STYLE">BORDER_END_STYLE</span>);
          borderProps.set(PropNames.<span class="jde-java-font-lock-constant" id="BORDER_END_WIDTH">BORDER_END_WIDTH</span>);
          borderProps.set(PropNames.<span class="jde-java-font-lock-constant" id="BORDER_END_WIDTH_LENGTH">BORDER_END_WIDTH_LENGTH</span>);
          borderProps.set(PropNames.<span class="jde-java-font-lock-constant" id="BORDER_END_WIDTH_CONDITIONALITY">BORDER_END_WIDTH_CONDITIONALITY</span>);
          borderProps.set(PropNames.<span class="jde-java-font-lock-constant" id="BORDER_LEFT">BORDER_LEFT</span>);
          borderProps.set(PropNames.<span class="jde-java-font-lock-constant" id="BORDER_LEFT_COLOR">BORDER_LEFT_COLOR</span>);
          borderProps.set(PropNames.<span class="jde-java-font-lock-constant" id="BORDER_LEFT_STYLE">BORDER_LEFT_STYLE</span>);
          borderProps.set(PropNames.<span class="jde-java-font-lock-constant" id="BORDER_LEFT_WIDTH">BORDER_LEFT_WIDTH</span>);
          borderProps.set(PropNames.<span class="jde-java-font-lock-constant" id="BORDER_RIGHT">BORDER_RIGHT</span>);
          borderProps.set(PropNames.<span class="jde-java-font-lock-constant" id="BORDER_RIGHT_COLOR">BORDER_RIGHT_COLOR</span>);
          borderProps.set(PropNames.<span class="jde-java-font-lock-constant" id="BORDER_RIGHT_STYLE">BORDER_RIGHT_STYLE</span>);
          borderProps.set(PropNames.<span class="jde-java-font-lock-constant" id="BORDER_RIGHT_WIDTH">BORDER_RIGHT_WIDTH</span>);
          borderProps.set(PropNames.<span class="jde-java-font-lock-constant" id="BORDER_START_COLOR">BORDER_START_COLOR</span>);
          borderProps.set(PropNames.<span class="jde-java-font-lock-constant" id="BORDER_START_STYLE">BORDER_START_STYLE</span>);
          borderProps.set(PropNames.<span class="jde-java-font-lock-constant" id="BORDER_START_WIDTH">BORDER_START_WIDTH</span>);
          borderProps.set(PropNames.<span class="jde-java-font-lock-constant" id="BORDER_START_WIDTH_LENGTH">BORDER_START_WIDTH_LENGTH</span>);
          borderProps.set(PropNames.<span class="jde-java-font-lock-constant" id="BORDER_START_WIDTH_CONDITIONALITY">BORDER_START_WIDTH_CONDITIONALITY</span>);
          borderProps.set(PropNames.<span class="jde-java-font-lock-constant" id="BORDER_STYLE">BORDER_STYLE</span>);
          borderProps.set(PropNames.<span class="jde-java-font-lock-constant" id="BORDER_TOP">BORDER_TOP</span>);
          borderProps.set(PropNames.<span class="jde-java-font-lock-constant" id="BORDER_TOP_COLOR">BORDER_TOP_COLOR</span>);
          borderProps.set(PropNames.<span class="jde-java-font-lock-constant" id="BORDER_TOP_STYLE">BORDER_TOP_STYLE</span>);
          borderProps.set(PropNames.<span class="jde-java-font-lock-constant" id="BORDER_TOP_WIDTH">BORDER_TOP_WIDTH</span>);
          borderProps.set(PropNames.<span class="jde-java-font-lock-constant" id="BORDER_WIDTH">BORDER_WIDTH</span>);
          borderSet = <span class="keyword">new</span> <span class="type">ROBitSet</span>(borderProps);
      }
      <span class="comment">/**
       * &lt;tt&gt;BitSet&lt;/tt&gt; of the &lt;tt&gt;Integer&lt;/tt&gt; objects corresponding to the
       * constant index of each property in the set of
       * &lt;b&gt;</span><span class="jde-java-font-lock-bold">Common Font Properties</span><span class="comment">&lt;/b&gt;.
       */</span>
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">BitSet</span> <span class="variable-name" id="fontProps">fontProps</span> = <span class="keyword">new</span> <span class="type">BitSet</span>();
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROBitSet</span> <span class="variable-name" id="fontSet">fontSet</span>;
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="type">BitSet</span> <span class="function-name" id="fontSetClone">fontSetClone</span>() {
          <span class="keyword">return</span> (<span class="type">BitSet</span>)(fontProps.clone());
      }
  
      <span class="jde-java-font-lock-modifier">static</span> {
          fontProps.set(PropNames.<span class="jde-java-font-lock-constant" id="FONT">FONT</span>);
          fontProps.set(PropNames.<span class="jde-java-font-lock-constant" id="FONT_FAMILY">FONT_FAMILY</span>);
          fontProps.set(PropNames.<span class="jde-java-font-lock-constant" id="FONT_SELECTION_STRATEGY">FONT_SELECTION_STRATEGY</span>);
          fontProps.set(PropNames.<span class="jde-java-font-lock-constant" id="FONT_SIZE">FONT_SIZE</span>);
          fontProps.set(PropNames.<span class="jde-java-font-lock-constant" id="FONT_SIZE_ADJUST">FONT_SIZE_ADJUST</span>);
          fontProps.set(PropNames.<span class="jde-java-font-lock-constant" id="FONT_STRETCH">FONT_STRETCH</span>);
          fontProps.set(PropNames.<span class="jde-java-font-lock-constant" id="FONT_STYLE">FONT_STYLE</span>);
          fontProps.set(PropNames.<span class="jde-java-font-lock-constant" id="FONT_VARIANT">FONT_VARIANT</span>);
          fontProps.set(PropNames.<span class="jde-java-font-lock-constant" id="FONT_WEIGHT">FONT_WEIGHT</span>);
          fontSet = <span class="keyword">new</span> <span class="type">ROBitSet</span>(fontProps);
      }
      <span class="comment">/**
       * &lt;tt&gt;BitSet&lt;/tt&gt; of the &lt;tt&gt;Integer&lt;/tt&gt; objects corresponding to the
       * constant index of each property in the set of
       * &lt;b&gt;</span><span class="jde-java-font-lock-bold">Common Hyphenation Properties</span><span class="comment">&lt;/b&gt;.
       */</span>
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">BitSet</span> <span class="variable-name" id="hyphenationProps">hyphenationProps</span> = <span class="keyword">new</span> <span class="type">BitSet</span>();
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROBitSet</span> <span class="variable-name" id="hyphenationSet">hyphenationSet</span>;
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="type">BitSet</span> <span class="function-name" id="hyphenationSetClone">hyphenationSetClone</span>() {
          <span class="keyword">return</span> (<span class="type">BitSet</span>)(hyphenationProps.clone());
      }
  
      <span class="jde-java-font-lock-modifier">static</span> {
          hyphenationProps.set(PropNames.<span class="jde-java-font-lock-constant" id="COUNTRY">COUNTRY</span>);
          hyphenationProps.set(PropNames.<span class="jde-java-font-lock-constant" id="LANGUAGE">LANGUAGE</span>);
          hyphenationProps.set(PropNames.<span class="jde-java-font-lock-constant" id="SCRIPT">SCRIPT</span>);
          hyphenationProps.set(PropNames.<span class="jde-java-font-lock-constant" id="HYPHENATE">HYPHENATE</span>);
          hyphenationProps.set(PropNames.<span class="jde-java-font-lock-constant" id="HYPHENATION_CHARACTER">HYPHENATION_CHARACTER</span>);
          hyphenationProps.set(PropNames.<span class="jde-java-font-lock-constant" id="HYPHENATION_PUSH_CHARACTER_COUNT">HYPHENATION_PUSH_CHARACTER_COUNT</span>);
          hyphenationProps.set(PropNames.<span class="jde-java-font-lock-constant" id="HYPHENATION_REMAIN_CHARACTER_COUNT">HYPHENATION_REMAIN_CHARACTER_COUNT</span>);
          hyphenationSet = <span class="keyword">new</span> <span class="type">ROBitSet</span>(hyphenationProps);
      }
      <span class="comment">/**
       * &lt;tt&gt;BitSet&lt;/tt&gt; of the &lt;tt&gt;Integer&lt;/tt&gt; objects corresponding to the
       * constant index of each property in the set of
       * &lt;b&gt;</span><span class="jde-java-font-lock-bold">Common Margin-Block Properties</span><span class="comment">&lt;/b&gt;.
       */</span>
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">BitSet</span> <span class="variable-name" id="marginBlockProps">marginBlockProps</span> = <span class="keyword">new</span> <span class="type">BitSet</span>();
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROBitSet</span> <span class="variable-name" id="marginBlockSet">marginBlockSet</span>;
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="type">BitSet</span> <span class="function-name" id="marginBlockSetClone">marginBlockSetClone</span>() {
          <span class="keyword">return</span> (<span class="type">BitSet</span>)(marginBlockProps.clone());
      }
  
      <span class="jde-java-font-lock-modifier">static</span> {
          marginBlockProps.set(PropNames.<span class="jde-java-font-lock-constant" id="MARGIN">MARGIN</span>);
          marginBlockProps.set(PropNames.<span class="jde-java-font-lock-constant" id="MARGIN_BOTTOM">MARGIN_BOTTOM</span>);
          marginBlockProps.set(PropNames.<span class="jde-java-font-lock-constant" id="MARGIN_LEFT">MARGIN_LEFT</span>);
          marginBlockProps.set(PropNames.<span class="jde-java-font-lock-constant" id="MARGIN_RIGHT">MARGIN_RIGHT</span>);
          marginBlockProps.set(PropNames.<span class="jde-java-font-lock-constant" id="MARGIN_TOP">MARGIN_TOP</span>);
          marginBlockSet = <span class="keyword">new</span> <span class="type">ROBitSet</span>(marginBlockProps);
      }
      <span class="comment">/**
       * &lt;tt&gt;BitSet&lt;/tt&gt; of the &lt;tt&gt;Integer&lt;/tt&gt; objects corresponding to the
       * constant index of each property in the set of
       * &lt;b&gt;</span><span class="jde-java-font-lock-bold">Common Margin-Inline Properties</span><span class="comment">&lt;/b&gt;.
       */</span>
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">BitSet</span> <span class="variable-name" id="marginInlineProps">marginInlineProps</span> = <span class="keyword">new</span> <span class="type">BitSet</span>();
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROBitSet</span> <span class="variable-name" id="marginInlineSet">marginInlineSet</span>;
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="type">BitSet</span> <span class="function-name" id="marginInlineSetClone">marginInlineSetClone</span>() {
          <span class="keyword">return</span> (<span class="type">BitSet</span>)(marginInlineProps.clone());
      }
  
      <span class="jde-java-font-lock-modifier">static</span> {
          marginInlineProps.set(PropNames.<span class="jde-java-font-lock-constant" id="SPACE_END">SPACE_END</span>);
          marginInlineProps.set(PropNames.<span class="jde-java-font-lock-constant" id="SPACE_START">SPACE_START</span>);
          marginInlineSet = <span class="keyword">new</span> <span class="type">ROBitSet</span>(marginInlineProps);
      }
      <span class="comment">/**
       * &lt;tt&gt;BitSet&lt;/tt&gt; of the &lt;tt&gt;Integer&lt;/tt&gt; objects corresponding to the
       * constant index of each property in the set of
       * &lt;b&gt;</span><span class="jde-java-font-lock-bold">Common Padding Properties</span><span class="comment">&lt;/b&gt;.
       */</span>
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">BitSet</span> <span class="variable-name" id="paddingProps">paddingProps</span> = <span class="keyword">new</span> <span class="type">BitSet</span>();
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROBitSet</span> <span class="variable-name" id="paddingSet">paddingSet</span>;
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="type">BitSet</span> <span class="function-name" id="paddingSetClone">paddingSetClone</span>() {
          <span class="keyword">return</span> (<span class="type">BitSet</span>)(paddingProps.clone());
      }
  
      <span class="jde-java-font-lock-modifier">static</span> {
          paddingProps.set(PropNames.<span class="jde-java-font-lock-constant" id="PADDING">PADDING</span>);
          paddingProps.set(PropNames.<span class="jde-java-font-lock-constant" id="PADDING_AFTER">PADDING_AFTER</span>);
          paddingProps.set(PropNames.<span class="jde-java-font-lock-constant" id="PADDING_AFTER_LENGTH">PADDING_AFTER_LENGTH</span>);
          paddingProps.set(PropNames.<span class="jde-java-font-lock-constant" id="PADDING_AFTER_CONDITIONALITY">PADDING_AFTER_CONDITIONALITY</span>);
          paddingProps.set(PropNames.<span class="jde-java-font-lock-constant" id="PADDING_BEFORE">PADDING_BEFORE</span>);
          paddingProps.set(PropNames.<span class="jde-java-font-lock-constant" id="PADDING_BEFORE_LENGTH">PADDING_BEFORE_LENGTH</span>);
          paddingProps.set(PropNames.<span class="jde-java-font-lock-constant" id="PADDING_BEFORE_CONDITIONALITY">PADDING_BEFORE_CONDITIONALITY</span>);
          paddingProps.set(PropNames.<span class="jde-java-font-lock-constant" id="PADDING_BOTTOM">PADDING_BOTTOM</span>);
          paddingProps.set(PropNames.<span class="jde-java-font-lock-constant" id="PADDING_END">PADDING_END</span>);
          paddingProps.set(PropNames.<span class="jde-java-font-lock-constant" id="PADDING_END_LENGTH">PADDING_END_LENGTH</span>);
          paddingProps.set(PropNames.<span class="jde-java-font-lock-constant" id="PADDING_END_CONDITIONALITY">PADDING_END_CONDITIONALITY</span>);
          paddingProps.set(PropNames.<span class="jde-java-font-lock-constant" id="PADDING_LEFT">PADDING_LEFT</span>);
          paddingProps.set(PropNames.<span class="jde-java-font-lock-constant" id="PADDING_RIGHT">PADDING_RIGHT</span>);
          paddingProps.set(PropNames.<span class="jde-java-font-lock-constant" id="PADDING_START">PADDING_START</span>);
          paddingProps.set(PropNames.<span class="jde-java-font-lock-constant" id="PADDING_START_LENGTH">PADDING_START_LENGTH</span>);
          paddingProps.set(PropNames.<span class="jde-java-font-lock-constant" id="PADDING_START_CONDITIONALITY">PADDING_START_CONDITIONALITY</span>);
          paddingProps.set(PropNames.<span class="jde-java-font-lock-constant" id="PADDING_TOP">PADDING_TOP</span>);
          paddingSet = <span class="keyword">new</span> <span class="type">ROBitSet</span>(paddingProps);
      }
      <span class="comment">/**
       * &lt;tt&gt;BitSet&lt;/tt&gt; of the &lt;tt&gt;Integer&lt;/tt&gt; objects corresponding to the
       * constant index of each property in the set of
       * &lt;b&gt;</span><span class="jde-java-font-lock-bold">Common Relative Position Properties</span><span class="comment">&lt;/b&gt;.
       */</span>
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">BitSet</span> <span class="variable-name" id="relativePositionProps">relativePositionProps</span> = <span class="keyword">new</span> <span class="type">BitSet</span>();
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROBitSet</span> <span class="variable-name" id="relativePositionSet">relativePositionSet</span>;
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="type">BitSet</span> <span class="function-name" id="relativePositionSetClone">relativePositionSetClone</span>() {
          <span class="keyword">return</span> (<span class="type">BitSet</span>)(relativePositionProps.clone());
      }
  
      <span class="jde-java-font-lock-modifier">static</span> {
          relativePositionProps.set(PropNames.<span class="jde-java-font-lock-constant" id="RELATIVE_POSITION">RELATIVE_POSITION</span>);
          relativePositionProps.set(PropNames.<span class="jde-java-font-lock-constant">BOTTOM</span>);
          relativePositionProps.set(PropNames.<span class="jde-java-font-lock-constant">LEFT</span>);
          relativePositionProps.set(PropNames.<span class="jde-java-font-lock-constant">RIGHT</span>);
          relativePositionProps.set(PropNames.<span class="jde-java-font-lock-constant">TOP</span>);
          relativePositionSet =
                      <span class="keyword">new</span> <span class="type">ROBitSet</span>(relativePositionProps);
      }
      <span class="comment">/**
       * &lt;tt&gt;BitSet&lt;/tt&gt; of the &lt;tt&gt;Integer&lt;/tt&gt; objects corresponding to the
       * constant index of each property in the set of
       * &lt;b&gt;</span><span class="jde-java-font-lock-bold">Common Table Properties</span><span class="comment">&lt;/b&gt;.
       */</span>
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">BitSet</span> <span class="variable-name" id="tableProps">tableProps</span> = <span class="keyword">new</span> <span class="type">BitSet</span>();
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROBitSet</span> <span class="variable-name" id="tableSet">tableSet</span>;
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="type">BitSet</span> <span class="function-name" id="tableSetClone">tableSetClone</span>() {
          <span class="keyword">return</span> (<span class="type">BitSet</span>)(tableProps.clone());
      }
  
      <span class="jde-java-font-lock-modifier">static</span> {
          tableProps.set(PropNames.<span class="jde-java-font-lock-constant" id="BORDER_AFTER_PRECEDENCE">BORDER_AFTER_PRECEDENCE</span>);
          tableProps.set(PropNames.<span class="jde-java-font-lock-constant" id="BORDER_BEFORE_PRECEDENCE">BORDER_BEFORE_PRECEDENCE</span>);
          tableProps.set(PropNames.<span class="jde-java-font-lock-constant" id="BORDER_COLLAPSE">BORDER_COLLAPSE</span>);
          tableProps.set(PropNames.<span class="jde-java-font-lock-constant" id="BORDER_END_PRECEDENCE">BORDER_END_PRECEDENCE</span>);
          tableProps.set(PropNames.<span class="jde-java-font-lock-constant" id="BORDER_SEPARATION">BORDER_SEPARATION</span>);
          tableProps.set(PropNames.<span class="jde-java-font-lock-constant" id="BORDER_SEPARATION_BLOCK_PROGRESSION_DIRECTION">BORDER_SEPARATION_BLOCK_PROGRESSION_DIRECTION</span>);
          tableProps.set(PropNames.<span class="jde-java-font-lock-constant" id="BORDER_SEPARATION_INLINE_PROGRESSION_DIRECTION">BORDER_SEPARATION_INLINE_PROGRESSION_DIRECTION</span>);
          tableProps.set(PropNames.<span class="jde-java-font-lock-constant" id="BORDER_SPACING">BORDER_SPACING</span>);
          tableProps.set(PropNames.<span class="jde-java-font-lock-constant" id="BORDER_START_PRECEDENCE">BORDER_START_PRECEDENCE</span>);
          tableProps.set(PropNames.<span class="jde-java-font-lock-constant" id="CAPTION_SIDE">CAPTION_SIDE</span>);
          tableProps.set(PropNames.<span class="jde-java-font-lock-constant" id="COLUMN_NUMBER">COLUMN_NUMBER</span>);
          tableProps.set(PropNames.<span class="jde-java-font-lock-constant" id="COLUMN_WIDTH">COLUMN_WIDTH</span>);
          tableProps.set(PropNames.<span class="jde-java-font-lock-constant" id="EMPTY_CELLS">EMPTY_CELLS</span>);
          tableProps.set(PropNames.<span class="jde-java-font-lock-constant" id="ENDS_ROW">ENDS_ROW</span>);
          tableProps.set(PropNames.<span class="jde-java-font-lock-constant" id="NUMBER_COLUMNS_REPEATED">NUMBER_COLUMNS_REPEATED</span>);
          tableProps.set(PropNames.<span class="jde-java-font-lock-constant" id="NUMBER_COLUMNS_SPANNED">NUMBER_COLUMNS_SPANNED</span>);
          tableProps.set(PropNames.<span class="jde-java-font-lock-constant" id="NUMBER_ROWS_SPANNED">NUMBER_ROWS_SPANNED</span>);
          tableProps.set(PropNames.<span class="jde-java-font-lock-constant" id="STARTS_ROW">STARTS_ROW</span>);
          tableProps.set(PropNames.<span class="jde-java-font-lock-constant" id="TABLE_LAYOUT">TABLE_LAYOUT</span>);
          tableProps.set(PropNames.<span class="jde-java-font-lock-constant" id="TABLE_OMIT_FOOTER_AT_BREAK">TABLE_OMIT_FOOTER_AT_BREAK</span>);
          tableProps.set(PropNames.<span class="jde-java-font-lock-constant" id="TABLE_OMIT_HEADER_AT_BREAK">TABLE_OMIT_HEADER_AT_BREAK</span>);
          tableSet = <span class="keyword">new</span> <span class="type">ROBitSet</span>(tableProps);
      }
  
      <span class="jde-java-font-lock-modifier">private</span> <span class="function-name" id="PropertySets">PropertySets</span> (){}
  
  }
  </pre>
    </body>
  </html>
  
  
  
  1.1                  xml-site/targets/fop/design/alt.design/properties/PropertyTokenizer.html
  
  Index: PropertyTokenizer.html
  ===================================================================
  <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN">
  <!-- Created by htmlize-0.67 in css mode. -->
  <html>
    <head>
      <title>PropertyTokenizer.java</title>
      <style type="text/css">
      <!--
        body {
          color: #000000;
          background-color: #faf0e6;
        } /* default */
        .function-name {
          color: #8b2323;
          background-color: #faf0e6;
        } /* font-lock-function-name-face */
        .jde-java-font-lock-italic {
          background-color: #faf0e6;
          font-style: italic;
        } /* jde-java-font-lock-italic-face */
        .jde-java-font-lock-modifier {
          color: #da70d6;
          background-color: #faf0e6;
        } /* jde-java-font-lock-modifier-face */
        .keyword {
          color: #8b0000;
          background-color: #faf0e6;
        } /* font-lock-keyword-face */
        .variable-name {
          color: #8b008b;
          background-color: #faf0e6;
        } /* font-lock-variable-name-face */
        .string {
          color: #008b00;
          background-color: #faf0e6;
        } /* font-lock-string-face */
        .jde-java-font-lock-package {
          color: #0000cd;
          background-color: #faf0e6;
        } /* jde-java-font-lock-package-face */
        .jde-java-font-lock-constant {
          color: #5f9ea0;
          background-color: #faf0e6;
        } /* jde-java-font-lock-constant-face */
        .type {
          color: #4682b4;
          background-color: #faf0e6;
        } /* font-lock-type-face */
        .jde-java-font-lock-doc-tag {
          color: #008b00;
          background-color: #faf0e6;
        } /* jde-java-font-lock-doc-tag-face */
        .comment {
          color: #00008b;
          background-color: #faf0e6;
        } /* font-lock-comment-face */
        .jde-java-font-lock-number {
          color: #bc8f8f;
          background-color: #faf0e6;
        } /* jde-java-font-lock-number-face */
        a {
          color: inherit;
          background-color: inherit;
          font: inherit;
          text-decoration: inherit;
        }
        a:hover {
          text-decoration: underline;
        }
      -->
      </style>
    </head>
    <body>
      <pre>
  <span class="comment">/*
   * $Id: PropertyTokenizer.html,v 1.1 2003/01/24 10:46:48 pbwest Exp $
   * Copyright (C) 2001 The Apache Software Foundation. All rights reserved.
   * For details on use and redistribution please refer to the
   * LICENSE file included with these sources.
   */</span>
  
  <span class="keyword">package</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="jde-java-font-lock-package">expr</span>;
  
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">Numeric</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">Length</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">Frequency</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">Time</span>;
  
  <span class="comment">/**
   * Class to tokenize XSL FO property expression.
   * This class is heavily based on the epxression tokenizer in James Clark's
   * XT, an XSLT processor.
   */</span>
  <span class="keyword">class</span> <span class="function-name" id="PropertyTokenizerClass">PropertyTokenizer</span> {
  
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">String</span> <span class="variable-name" id="tag">tag</span> = &quot;<span class="string">$Name:  $</span>&quot;;
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">String</span> <span class="variable-name" id="revision">revision</span> = &quot;<span class="string">$Revision: 1.1 $</span>&quot;;
  
      <span class="comment">/*
       * Maintain the numbering of this list in (X)Emacs by issuing
       * a shell command on the region with replacement (M-1 M-|).  Use
       * the perl command:
       * perl -p -e 'BEGIN{$n=0};$n++ if s/= [0-9]+/= $n/'
       *
       * in vi, set mark `</span><span class="jde-java-font-lock-doc-tag">a</span><span class="comment">' at the last line and
       * !'aperl... etc
       */</span>
      <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span>
                   <span class="jde-java-font-lock-constant" id="EOF">EOF</span> = <span class="jde-java-font-lock-number">0</span>
               ,<span class="jde-java-font-lock-constant" id="NCNAME">NCNAME</span> = <span class="jde-java-font-lock-number">1</span>
             ,<span class="jde-java-font-lock-constant" id="MULTIPLY">MULTIPLY</span> = <span class="jde-java-font-lock-number">2</span>
                 ,<span class="jde-java-font-lock-constant" id="LPAR">LPAR</span> = <span class="jde-java-font-lock-number">3</span>
                 ,<span class="jde-java-font-lock-constant" id="RPAR">RPAR</span> = <span class="jde-java-font-lock-number">4</span>
              ,<span class="jde-java-font-lock-constant" id="LITERAL">LITERAL</span> = <span class="jde-java-font-lock-number">5</span>
        ,<span class="jde-java-font-lock-constant" id="FUNCTION_LPAR">FUNCTION_LPAR</span> = <span class="jde-java-font-lock-number">6</span>
                 ,<span class="jde-java-font-lock-constant" id="PLUS">PLUS</span> = <span class="jde-java-font-lock-number">7</span>
                ,<span class="jde-java-font-lock-constant" id="MINUS">MINUS</span> = <span class="jde-java-font-lock-number">8</span>
                  ,<span class="jde-java-font-lock-constant" id="MOD">MOD</span> = <span class="jde-java-font-lock-number">9</span>
                  ,<span class="jde-java-font-lock-constant" id="DIV">DIV</span> = <span class="jde-java-font-lock-number">10</span>
                ,<span class="jde-java-font-lock-constant" id="COMMA">COMMA</span> = <span class="jde-java-font-lock-number">11</span>
              ,<span class="jde-java-font-lock-constant" id="PERCENT">PERCENT</span> = <span class="jde-java-font-lock-number">12</span>
            ,<span class="jde-java-font-lock-constant" id="COLORSPEC">COLORSPEC</span> = <span class="jde-java-font-lock-number">13</span>
                ,<span class="jde-java-font-lock-constant" id="FLOAT">FLOAT</span> = <span class="jde-java-font-lock-number">14</span>
              ,<span class="jde-java-font-lock-constant" id="INTEGER">INTEGER</span> = <span class="jde-java-font-lock-number">15</span>
      ,<span class="jde-java-font-lock-constant" id="ABSOLUTE_LENGTH">ABSOLUTE_LENGTH</span> = <span class="jde-java-font-lock-number">16</span>
      ,<span class="jde-java-font-lock-constant" id="RELATIVE_LENGTH">RELATIVE_LENGTH</span> = <span class="jde-java-font-lock-number">17</span>
                 ,<span class="jde-java-font-lock-constant" id="TIME">TIME</span> = <span class="jde-java-font-lock-number">18</span>
                 ,<span class="jde-java-font-lock-constant" id="FREQ">FREQ</span> = <span class="jde-java-font-lock-number">19</span>
                ,<span class="jde-java-font-lock-constant" id="ANGLE">ANGLE</span> = <span class="jde-java-font-lock-number">20</span>
              ,<span class="jde-java-font-lock-constant" id="INHERIT">INHERIT</span> = <span class="jde-java-font-lock-number">21</span>
                 ,<span class="jde-java-font-lock-constant" id="AUTO">AUTO</span> = <span class="jde-java-font-lock-number">22</span>
                 ,<span class="jde-java-font-lock-constant" id="NONE">NONE</span> = <span class="jde-java-font-lock-number">23</span>
                 ,<span class="jde-java-font-lock-constant" id="BOOL">BOOL</span> = <span class="jde-java-font-lock-number">24</span>
                  ,<span class="jde-java-font-lock-constant" id="URI">URI</span> = <span class="jde-java-font-lock-number">25</span>
             ,<span class="jde-java-font-lock-constant" id="MIMETYPE">MIMETYPE</span> = <span class="jde-java-font-lock-number">26</span>
                ,<span class="jde-java-font-lock-constant" id="SLASH">SLASH</span> = <span class="jde-java-font-lock-number">27</span>
              <span class="comment">// NO_UNIT is a transient token for internal use only.  It is
  </span>            <span class="comment">// never set as the end result of parsing a token.
  </span>            ,<span class="jde-java-font-lock-constant" id="NO_UNIT">NO_UNIT</span> = <span class="jde-java-font-lock-number">28</span>
              <span class="comment">//,NSPREFIX = 29
  </span>            <span class="comment">//,WHITESPACE = 30
  </span>                     ;
  
      <span class="comment">/*
       * Absolute unit type constants
       */</span>
      <span class="type">int</span> <span class="variable-name" id="currentToken">currentToken</span> = <span class="jde-java-font-lock-constant">EOF</span>;
      <span class="type">String</span> <span class="variable-name" id="currentTokenValue">currentTokenValue</span> = <span class="jde-java-font-lock-constant" id="null">null</span>;
      <span class="jde-java-font-lock-modifier">protected</span> <span class="type">int</span> <span class="variable-name" id="currentUnitIndex">currentUnitIndex</span> = <span class="jde-java-font-lock-number">0</span>;
      <span class="jde-java-font-lock-modifier">protected</span> <span class="type">int</span> <span class="variable-name" id="currentUnit">currentUnit</span>;
      <span class="jde-java-font-lock-modifier">protected</span> <span class="type">String</span> <span class="variable-name" id="unitString">unitString</span>;
      <span class="jde-java-font-lock-modifier">protected</span> <span class="type">String</span> <span class="variable-name" id="uri">uri</span>;
  
      <span class="jde-java-font-lock-modifier">private</span> <span class="type">int</span> <span class="variable-name" id="currentTokenStartIndex">currentTokenStartIndex</span> = <span class="jde-java-font-lock-number">0</span>;
      <span class="jde-java-font-lock-modifier">private</span> <span class="type">String</span> <span class="variable-name" id="expr">expr</span> = <span class="jde-java-font-lock-constant">null</span>;
      <span class="jde-java-font-lock-modifier">private</span> <span class="type">int</span> <span class="variable-name" id="exprIndex">exprIndex</span> = <span class="jde-java-font-lock-number">0</span>;
      <span class="jde-java-font-lock-modifier">private</span> <span class="type">int</span> <span class="variable-name" id="exprLength">exprLength</span>;
      <span class="jde-java-font-lock-modifier">protected</span> <span class="type">int</span> <span class="variable-name" id="property">property</span>;
  
      <span class="jde-java-font-lock-modifier">protected</span> <span class="function-name" id="PropertyTokenizer">PropertyTokenizer</span>() {}
  
      <span class="comment">/**
       * Initialize this tokenizer to tokenize the passed
       * String as a value of the passed property.
       * It is assumed that the subclass has made any necessary
       * synchronization arrangements.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">property</span><span class="comment"> an &lt;tt&gt;int&lt;/tt&gt; containing the property index.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="s">s</span><span class="comment"> The Property expression to tokenize.
       */</span>
      <span class="jde-java-font-lock-modifier">protected</span> <span class="type">void</span> <span class="function-name" id="initialize">initialize</span>(<span class="type">int</span> <span class="variable-name">property</span>, <span class="type">String</span> <span class="variable-name">s</span>) {
          expr = s;
          exprLength = s.length();
          <span class="keyword">this</span>.property = property;
          <span class="comment">//System.out.println(&quot;-----Tokenizer initialized: &quot; + expr);
  </span>    }
  
      <span class="comment">/**
       * Reset the tokenizer to null (or equivalent) values.
       * Synchronization is achieved in the subclass.
       */</span>
      <span class="jde-java-font-lock-modifier">protected</span> <span class="type">void</span> <span class="function-name" id="reset">reset</span>() {
          expr = <span class="jde-java-font-lock-constant">null</span>;
          exprIndex = <span class="jde-java-font-lock-number">0</span>;
          exprLength = <span class="jde-java-font-lock-number">0</span>;
          currentToken = <span class="jde-java-font-lock-constant">EOF</span>;
          currentTokenValue = <span class="jde-java-font-lock-constant">null</span>;
          property = <span class="jde-java-font-lock-number">0</span>;
          <span class="comment">//System.out.println(&quot;-----Tokenizer reset.&quot;);
  </span>    }
  
      <span class="comment">/**
       * Get the current expression
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> - the expression.
       */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">String</span> <span class="function-name" id="getExpr">getExpr</span>() {
          <span class="keyword">return</span> expr;
      }
  
      <span class="comment">/**
       * Return the next token in the expression string.
       * This sets the following package visible variables:
       * currentToken  An enumerated value identifying the recognized token
       * currentTokenValue  A String containing the token contents
       * currentUnit  If currentToken = ABSOLUTE_LENGTH, TIME or FREQUENCY,
       * an enumerated value identifying the unit.
       * </span><span class="jde-java-font-lock-doc-tag">@throws</span><span class="comment"> </span><span class="type">PropertyException</span><span class="comment"> If un unrecognized token is encountered.
       */</span>
      <span class="type">void</span> <span class="function-name" id="next">next</span>() <span class="keyword">throws</span> <span class="type">PropertyException</span> {
          <span class="comment">//System.out.println(&quot;expr:&quot; + expr + &quot;:  exprIndex: &quot; + exprIndex);
  </span>        currentTokenValue = <span class="jde-java-font-lock-constant">null</span>;
          currentTokenStartIndex = exprIndex;
          <span class="type">boolean</span> <span class="variable-name" id="bSawDecimal">bSawDecimal</span>;
          <span class="keyword">for</span> (; ; ) {
              <span class="keyword">if</span> (exprIndex &gt;= exprLength) {
                  currentToken = <span class="jde-java-font-lock-constant">EOF</span>;
                  <span class="keyword">return</span>;
              }
              <span class="type">char</span> <span class="variable-name" id="c">c</span> = expr.charAt(exprIndex++);
              <span class="keyword">switch</span> (c) {
              <span class="keyword">case</span> '<span class="string"> </span>':
              <span class="keyword">case</span> '<span class="string">\t</span>':
              <span class="keyword">case</span> '<span class="string">\r</span>':
              <span class="keyword">case</span> '<span class="string">\n</span>':
                  <span class="comment">// Whitespace characters are valid within strings.
  </span>                <span class="comment">// in font family names, sequences of whitespace are
  </span>                <span class="comment">// compressed into a single space. (Rec 7.8.2)
  </span>                <span class="comment">//scanWhitespace();
  </span>                <span class="comment">//currentToken = WHITESPACE;
  </span>                <span class="comment">//currentTokenValue = expr.substring(currentTokenStartIndex,
  </span>                <span class="comment">//                                   exprIndex);
  </span>                <span class="comment">//return;
  </span>                currentTokenStartIndex = exprIndex;
                  <span class="keyword">break</span>;
              <span class="keyword">case</span> '<span class="string">,</span>':
                  currentToken = <span class="jde-java-font-lock-constant">COMMA</span>;
                  <span class="keyword">return</span>;
              <span class="keyword">case</span> '<span class="string">+</span>':
                  currentToken = <span class="jde-java-font-lock-constant">PLUS</span>;
                  <span class="keyword">return</span>;
              <span class="keyword">case</span> '<span class="string">-</span>':
                  currentToken = <span class="jde-java-font-lock-constant">MINUS</span>;
                  <span class="keyword">return</span>;
              <span class="keyword">case</span> '<span class="string">(</span>':
                  currentToken = <span class="jde-java-font-lock-constant">LPAR</span>;
                  <span class="keyword">return</span>;
              <span class="keyword">case</span> '<span class="string">)</span>':
                  currentToken = <span class="jde-java-font-lock-constant">RPAR</span>;
                  <span class="keyword">return</span>;
              <span class="keyword">case</span> '<span class="string">&quot;</span>':
              <span class="keyword">case</span> '<span class="string">\'</span>':
                  exprIndex = expr.indexOf(c, exprIndex);
                  <span class="keyword">if</span> (exprIndex &lt; <span class="jde-java-font-lock-number">0</span>) {
                      exprIndex = currentTokenStartIndex + <span class="jde-java-font-lock-number">1</span>;
                      <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(&quot;<span class="string">missing quote</span>&quot;);
                  }
                  currentTokenValue = expr.substring(currentTokenStartIndex
                                                     + <span class="jde-java-font-lock-number">1</span>, exprIndex++);
                  currentToken = <span class="jde-java-font-lock-constant">LITERAL</span>;
                  <span class="keyword">return</span>;
              <span class="keyword">case</span> '<span class="string">*</span>':
                  currentToken = <span class="jde-java-font-lock-constant">MULTIPLY</span>;
                  <span class="keyword">return</span>;
              <span class="keyword">case</span> '<span class="string">0</span>':
              <span class="keyword">case</span> '<span class="string">1</span>':
              <span class="keyword">case</span> '<span class="string">2</span>':
              <span class="keyword">case</span> '<span class="string">3</span>':
              <span class="keyword">case</span> '<span class="string">4</span>':
              <span class="keyword">case</span> '<span class="string">5</span>':
              <span class="keyword">case</span> '<span class="string">6</span>':
              <span class="keyword">case</span> '<span class="string">7</span>':
              <span class="keyword">case</span> '<span class="string">8</span>':
              <span class="keyword">case</span> '<span class="string">9</span>':
                  scanDigits();
                  <span class="keyword">if</span> (exprIndex &lt; exprLength &amp;&amp; expr.charAt(exprIndex) == '<span class="string">.</span>') {
                      exprIndex++;
                      bSawDecimal = <span class="jde-java-font-lock-constant" id="true">true</span>;
                      <span class="keyword">if</span> (exprIndex &lt; exprLength
                              &amp;&amp; isDigit(expr.charAt(exprIndex))) {
                          exprIndex++;
                          scanDigits();
                      }
                  } <span class="keyword">else</span>
                      bSawDecimal = <span class="jde-java-font-lock-constant" id="false">false</span>;
                  currentUnitIndex = exprIndex;
                  <span class="keyword">if</span> (exprIndex &lt; exprLength &amp;&amp; expr.charAt(exprIndex) == '<span class="string">%</span>') {
                      currentToken = <span class="jde-java-font-lock-constant">PERCENT</span>;
                      unitString = &quot;<span class="string">%</span>&quot;;
                      exprIndex++;
                  } <span class="keyword">else</span> {
                      <span class="comment">// Check for possible unit name following number
  </span>                    currentToken = scanUnitName();
                      <span class="keyword">if</span> (currentToken == <span class="jde-java-font-lock-constant">NO_UNIT</span>)
                          currentToken = bSawDecimal ? <span class="jde-java-font-lock-constant">FLOAT</span> : <span class="jde-java-font-lock-constant">INTEGER</span>;
                  }
                  currentTokenValue = expr.substring(currentTokenStartIndex,
                                                     currentUnitIndex);
                  <span class="keyword">return</span>;
  
              <span class="keyword">case</span> '<span class="string">.</span>':
                  <span class="keyword">if</span> (exprIndex &lt; exprLength
                          &amp;&amp; isDigit(expr.charAt(exprIndex))) {
                      ++exprIndex;
                      scanDigits();
                      currentUnitIndex = exprIndex;
                      <span class="keyword">if</span> (exprIndex &lt; exprLength
                              &amp;&amp; expr.charAt(exprIndex) == '<span class="string">%</span>') {
                          exprIndex++;
                          currentToken = <span class="jde-java-font-lock-constant">PERCENT</span>;
                      } <span class="keyword">else</span> {
                          <span class="comment">// Check for possible unit name following number
  </span>                        currentToken = scanUnitName();
                          <span class="keyword">if</span> (currentToken == <span class="jde-java-font-lock-constant">NO_UNIT</span>)
                              currentToken = <span class="jde-java-font-lock-constant">FLOAT</span>;
                      }
                      currentTokenValue = expr.substring(currentTokenStartIndex,
                                                         currentUnitIndex);
                      <span class="keyword">return</span>;
                  }
                  <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(&quot;<span class="string">illegal character '.'</span>&quot;);
  
              <span class="keyword">case</span> '<span class="string">#</span>':    <span class="comment">// Start of color value
  </span>                <span class="keyword">if</span> (exprIndex &lt; exprLength
                          &amp;&amp; isHexDigit(expr.charAt(exprIndex))) {
                      <span class="type">int</span> <span class="variable-name" id="len">len</span>;
                      ++exprIndex;
                      scanHexDigits();
                      currentToken = <span class="jde-java-font-lock-constant">COLORSPEC</span>;
                      currentTokenValue = expr.substring(currentTokenStartIndex,
                                                         exprIndex);
                      <span class="comment">// Probably should have some multiple of 3 for length!
  </span>                    len = exprIndex - currentTokenStartIndex;
                      <span class="keyword">if</span> (len == <span class="jde-java-font-lock-number">4</span> || len == <span class="jde-java-font-lock-number">7</span>) <span class="keyword">return</span>;
                      <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(&quot;<span class="string">color not 3 or 6 hex digits</span>&quot;);
                  } <span class="keyword">else</span> {
                      <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(&quot;<span class="string">illegal character '#'</span>&quot;);
                  }
  
              <span class="keyword">case</span> '<span class="string">/</span>':
                  currentToken = <span class="jde-java-font-lock-constant">SLASH</span>;
                  <span class="keyword">return</span>;
  
              <span class="keyword">default</span>:
                  --exprIndex;
                  scanName();
                  <span class="keyword">if</span> (exprIndex == currentTokenStartIndex)
                      <span class="comment">// Not a name - must be a &lt;string&gt;
  </span>                    <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>
                              (&quot;<span class="string">illegal character '</span>&quot;
                               + expr.charAt(exprIndex) + &quot;<span class="string">'</span>&quot;);
                  currentTokenValue = expr.substring(currentTokenStartIndex,
                                                     exprIndex);
                  <span class="keyword">if</span> (currentTokenValue.equals(&quot;<span class="string">mod</span>&quot;)) {
                      currentToken = <span class="jde-java-font-lock-constant">MOD</span>;
                     <span class="keyword">return</span>;
                  }
                  <span class="keyword">if</span> (currentTokenValue.equals(&quot;<span class="string">div</span>&quot;)) {
                      currentToken = <span class="jde-java-font-lock-constant">DIV</span>;
                      <span class="keyword">return</span>;
                  }
                  <span class="keyword">if</span> (currentTokenValue.equals(&quot;<span class="string">inherit</span>&quot;)) {
                      currentToken = <span class="jde-java-font-lock-constant">INHERIT</span>;
                      <span class="keyword">return</span>;
                  }
                  <span class="keyword">if</span> (currentTokenValue.equals(&quot;<span class="string">auto</span>&quot;)) {
                      currentToken = <span class="jde-java-font-lock-constant">AUTO</span>;
                      <span class="keyword">return</span>;
                  }
                  <span class="keyword">if</span> (currentTokenValue.equals(&quot;<span class="string">none</span>&quot;)) {
                      currentToken = <span class="jde-java-font-lock-constant">NONE</span>;
                      <span class="keyword">return</span>;
                  }
                  <span class="keyword">if</span> (currentTokenValue.equals(&quot;<span class="string">true</span>&quot;)
                      || currentTokenValue.equals(&quot;<span class="string">false</span>&quot;)) {
                      currentToken = <span class="jde-java-font-lock-constant">BOOL</span>;
                      <span class="keyword">return</span>;
                  }
                  <span class="comment">// Quick and dirty url &quot;parsing&quot;.  Assume that a
  </span>                <span class="comment">// URI-SPECIFICATION must be the only component of a
  </span>                <span class="comment">// property value expression
  </span>                <span class="keyword">if</span> (currentTokenValue.equals(&quot;<span class="string">url</span>&quot;)
                      &amp;&amp; expr.charAt(exprIndex) == '<span class="string">(</span>') {
                      <span class="keyword">if</span> (! scanUrl()) {
                          <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>
                                  (&quot;<span class="string">Invalid url expression :</span>&quot; +
                                   expr.substring(exprIndex));
                      }
                      currentToken = <span class="jde-java-font-lock-constant">URI</span>;
                      <span class="keyword">return</span>;
                  }
                  <span class="keyword">if</span> (currentTokenValue.equals(&quot;<span class="string">content-type</span>&quot;)) {
                      <span class="comment">// content-type attribute value.  Must be followed
  </span>                    <span class="comment">// by a mime type
  </span>                    <span class="keyword">if</span> (expr.charAt(exprIndex) == '<span class="string">:</span>') {
                          <span class="type">int</span> <span class="variable-name" id="mimeptr">mimeptr</span> = ++exprIndex;
                          scanMimeType();
                          currentToken = <span class="jde-java-font-lock-constant">MIMETYPE</span>;
                          currentTokenValue =
                                  expr.substring(mimeptr, exprIndex);
                          <span class="keyword">return</span>;
                      }
                      <span class="comment">// else it's just a name
  </span>                }
                  <span class="keyword">if</span> (currentTokenValue.equals(&quot;<span class="string">namespace-prefix</span>&quot;)) {
                      <span class="comment">// content-type attribute value.  Must be followed
  </span>                    <span class="comment">// by a declared namespace-prefix or null
  </span>                    <span class="keyword">if</span> (expr.charAt(exprIndex) == '<span class="string">:</span>') {
                          <span class="type">int</span> <span class="variable-name" id="nsptr">nsptr</span> = ++exprIndex;
                          scanName();   <span class="comment">// Allowed to be empty
  </span>                        currentToken = <span class="jde-java-font-lock-constant">NCNAME</span>;
                          currentTokenValue =
                                  expr.substring(nsptr, exprIndex);
                          <span class="keyword">return</span>;
                      }
                      <span class="comment">// else it's just a name
  </span>                }
                  <span class="keyword">if</span> (followingParen()) {
                      currentToken = <span class="jde-java-font-lock-constant">FUNCTION_LPAR</span>;
                  } <span class="keyword">else</span> {
                      currentToken = <span class="jde-java-font-lock-constant">NCNAME</span>;
                  }
                  <span class="keyword">return</span>;
              }
          }
      }
  
      <span class="comment">/**
       * Attempt to recognize a valid UnitName token in the input expression.
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> token value appropriate to UnitName: ABSOLUTE_LENGTH,
       * RELATIVE_LENGTH or NO_UNIT.
       * </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">PropertyException</span><span class="comment"> if an NCName not a UnitName recognized.
       */</span>
      <span class="jde-java-font-lock-modifier">private</span> <span class="type">int</span> <span class="function-name" id="scanUnitName">scanUnitName</span>() <span class="keyword">throws</span> <span class="type">PropertyException</span> {
          currentUnitIndex = exprIndex;
          scanName();
          <span class="keyword">if</span> (currentUnitIndex &lt; exprIndex) {
              unitString = expr.substring(currentUnitIndex, exprIndex);
              <span class="keyword">if</span> (unitString.equals(&quot;<span class="string">em</span>&quot;)) <span class="keyword">return</span> <span class="jde-java-font-lock-constant">RELATIVE_LENGTH</span>;
              <span class="keyword">if</span> (unitString.equals(&quot;<span class="string">cm</span>&quot;)) {
                  currentUnit = Length.<span class="jde-java-font-lock-constant" id="CM">CM</span>;
                  <span class="keyword">return</span> <span class="jde-java-font-lock-constant">ABSOLUTE_LENGTH</span>;
              }
              <span class="keyword">if</span> (unitString.equals(&quot;<span class="string">mm</span>&quot;)) {
                  currentUnit = Length.<span class="jde-java-font-lock-constant" id="MM">MM</span>;
                  <span class="keyword">return</span> <span class="jde-java-font-lock-constant">ABSOLUTE_LENGTH</span>;
              }
              <span class="keyword">if</span> (unitString.equals(&quot;<span class="string">in</span>&quot;)) {
                  currentUnit = Length.<span class="jde-java-font-lock-constant" id="IN">IN</span>;
                  <span class="keyword">return</span> <span class="jde-java-font-lock-constant">ABSOLUTE_LENGTH</span>;
              }
              <span class="keyword">if</span> (unitString.equals(&quot;<span class="string">pt</span>&quot;)) {
                  currentUnit = Length.<span class="jde-java-font-lock-constant" id="PT">PT</span>;
                  <span class="keyword">return</span> <span class="jde-java-font-lock-constant">ABSOLUTE_LENGTH</span>;
              }
              <span class="keyword">if</span> (unitString.equals(&quot;<span class="string">pc</span>&quot;)) {
                  currentUnit = Length.<span class="jde-java-font-lock-constant" id="PC">PC</span>;
                  <span class="keyword">return</span> <span class="jde-java-font-lock-constant">ABSOLUTE_LENGTH</span>;
              }
              <span class="keyword">if</span> (unitString.equals(&quot;<span class="string">px</span>&quot;)) {
                  currentUnit = Length.<span class="jde-java-font-lock-constant" id="PX">PX</span>;
                  <span class="keyword">return</span> <span class="jde-java-font-lock-constant">ABSOLUTE_LENGTH</span>;
              }
              <span class="keyword">if</span> (unitString.equals(&quot;<span class="string">s</span>&quot;)) {
                  currentUnit = Time.<span class="jde-java-font-lock-constant" id="SEC">SEC</span>;
                  <span class="keyword">return</span> <span class="jde-java-font-lock-constant">TIME</span>;
              }
              <span class="keyword">if</span> (unitString.equals(&quot;<span class="string">ms</span>&quot;)) {
                  currentUnit = Time.<span class="jde-java-font-lock-constant" id="MSEC">MSEC</span>;
                  <span class="keyword">return</span> <span class="jde-java-font-lock-constant">TIME</span>;
              }
              <span class="keyword">if</span> (unitString.equals(&quot;<span class="string">Hz</span>&quot;)) {
                  currentUnit = Frequency.<span class="jde-java-font-lock-constant" id="HZ">HZ</span>;
                  <span class="keyword">return</span> <span class="jde-java-font-lock-constant">FREQ</span>;
              }
              <span class="keyword">if</span> (unitString.equals(&quot;<span class="string">kHz</span>&quot;)) {
                  currentUnit = Frequency.<span class="jde-java-font-lock-constant" id="KHZ">KHZ</span>;
                  <span class="keyword">return</span> <span class="jde-java-font-lock-constant">FREQ</span>;
              }
              <span class="comment">// Not a UnitName
  </span>            <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>
                      (&quot;<span class="string">NCName following a number is not a UnitName</span>&quot;);
          } <span class="keyword">else</span> { <span class="comment">// No NCName found
  </span>            <span class="keyword">return</span> <span class="jde-java-font-lock-constant">NO_UNIT</span>;
          }
      }
  
      <span class="comment">/**
       * Attempt to recognize a valid NAME token in the input expression.
       */</span>
      <span class="jde-java-font-lock-modifier">private</span> <span class="type">void</span> <span class="function-name" id="scanName">scanName</span>() {
          <span class="keyword">if</span> (exprIndex &lt; exprLength &amp;&amp; isNameStartChar(expr.charAt(exprIndex)))
              <span class="keyword">while</span> (++exprIndex &lt; exprLength
                     &amp;&amp; isNameChar(expr.charAt(exprIndex)));
      }
  
      <span class="comment">/**
       * Attempt to recognize a valid sequence of decimal digits in the
       * input expression.
       */</span>
      <span class="jde-java-font-lock-modifier">private</span> <span class="type">void</span> <span class="function-name" id="scanDigits">scanDigits</span>() {
          <span class="keyword">while</span> (exprIndex &lt; exprLength &amp;&amp; isDigit(expr.charAt(exprIndex)))
              exprIndex++;
      }
  
      <span class="comment">/**
       * Scan to the end of a sequence of whitespace characters in the
       * input expression.
       */</span>
      <span class="jde-java-font-lock-modifier">private</span> <span class="type">void</span> <span class="function-name" id="scanWhitespace">scanWhitespace</span>() {
          <span class="keyword">while</span> (exprIndex &lt; exprLength &amp;&amp; isSpace(expr.charAt(exprIndex)))
              exprIndex++;
      }
  
      <span class="comment">/**
       * Attempt to recognize a valid sequence of hexadecimal digits in the
       * input expression.
       */</span>
      <span class="jde-java-font-lock-modifier">private</span> <span class="type">void</span> <span class="function-name" id="scanHexDigits">scanHexDigits</span>() {
          <span class="keyword">while</span> (exprIndex &lt; exprLength &amp;&amp; isHexDigit(expr.charAt(exprIndex)))
              exprIndex++;
      }
  
      <span class="comment">/**
       * Attempt to recognize a mime-type.  Working definition here:
       * NCName/NCName (NCName as recognized by scanName()).
       */</span>
      <span class="jde-java-font-lock-modifier">private</span> <span class="type">void</span> <span class="function-name" id="scanMimeType">scanMimeType</span>() <span class="keyword">throws</span> <span class="type">PropertyException</span> {
          <span class="type">int</span> <span class="variable-name" id="part1">part1</span> = exprIndex;
          scanName();
          <span class="keyword">if</span> (part1 != exprIndex) {
              <span class="keyword">if</span> (expr.charAt(exprIndex) == '<span class="string">/</span>') {
                  <span class="type">int</span> <span class="variable-name" id="part2">part2</span> = ++exprIndex;
                  scanName();
                  <span class="keyword">if</span> (part2 != exprIndex)
                      <span class="keyword">return</span>;
              }
          }
          <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(&quot;<span class="string">Mime type expected; found:</span>&quot; +
                                      expr.substring(part1));
      }
  
      <span class="comment">/**
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> a boolean value indicating whether the following non-whitespace
       * character is an opening parenthesis.
       */</span>
      <span class="jde-java-font-lock-modifier">private</span> <span class="type">boolean</span> <span class="function-name" id="followingParen">followingParen</span>() {
          <span class="keyword">for</span> (<span class="type">int</span> <span class="variable-name" id="i">i</span> = exprIndex; i &lt; exprLength; i++) {
              <span class="keyword">switch</span> (expr.charAt(i)) {
              <span class="keyword">case</span> '<span class="string">(</span>':
                  exprIndex = i + <span class="jde-java-font-lock-number">1</span>;
                  <span class="keyword">return</span> <span class="jde-java-font-lock-constant">true</span>;
              <span class="keyword">case</span> '<span class="string"> </span>':
              <span class="keyword">case</span> '<span class="string">\r</span>':
              <span class="keyword">case</span> '<span class="string">\n</span>':
              <span class="keyword">case</span> '<span class="string">\t</span>':
                  <span class="keyword">break</span>;
              <span class="keyword">default</span>:
                  <span class="keyword">return</span> <span class="jde-java-font-lock-constant">false</span>;
              }
          }
          <span class="keyword">return</span> <span class="jde-java-font-lock-constant">false</span>;
      }
  
      <span class="comment">/**
       * Primitive URI extractor.  Assumes that the only contents of a
       * URI-SPECIFICATION property type is a complete uri-specification.
       * No checking is done on the syntactical validity of the URI.
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> a boolean indicating whether the remainder of the
       * characters form the body of a &lt;tt&gt;url(...)&lt;/tt&gt; specification.
       * As a side-effect, sets the &lt;tt&gt;protected&lt;/tt&gt; field &lt;i&gt;</span><span class="jde-java-font-lock-italic">uri</span><span class="comment">&lt;/i&gt;
       * and sets &lt;i&gt;</span><span class="jde-java-font-lock-italic">exprIndex</span><span class="comment">&lt;/i&gt; past the end of the expression, when
       * returning a &lt;tt&gt;true&lt;/tt&gt; value.
       */</span>
      <span class="jde-java-font-lock-modifier">private</span> <span class="type">boolean</span> <span class="function-name" id="scanUrl">scanUrl</span>() {
          <span class="type">char</span> <span class="variable-name" id="ch">ch</span>;
          <span class="type">String</span> <span class="variable-name" id="str">str</span> = expr.substring(exprIndex).trim();
          <span class="keyword">if</span> (str.charAt(str.length() - <span class="jde-java-font-lock-number">1</span>) != '<span class="string">)</span>') <span class="keyword">return</span> <span class="jde-java-font-lock-constant">false</span>;
          <span class="comment">// Remove closing parenthesis and trim
  </span>        str = str.substring(<span class="jde-java-font-lock-number">0</span>, str.length() - <span class="jde-java-font-lock-number">1</span>).trim();
          <span class="keyword">if</span> ((ch = str.charAt(<span class="jde-java-font-lock-number">0</span>)) == '<span class="string">&quot;</span>' || ch == '<span class="string">\'</span>') {
              <span class="keyword">if</span> (str.charAt(str.length() - <span class="jde-java-font-lock-number">1</span>) != ch) <span class="keyword">return</span> <span class="jde-java-font-lock-constant">false</span>;
              str = str.substring(<span class="jde-java-font-lock-number">1</span>, str.length() - <span class="jde-java-font-lock-number">1</span>);
          }
          uri = str.trim();
          exprIndex = expr.length();
          <span class="keyword">return</span> <span class="jde-java-font-lock-constant">true</span>;
      }
  
      <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">String</span> <span class="variable-name" id="nameStartChars">nameStartChars</span> =
          &quot;<span class="string">_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ</span>&quot;;
      <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">String</span> <span class="variable-name" id="nameChars">nameChars</span> = &quot;<span class="string">.-0123456789</span>&quot;;
      <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">String</span> <span class="variable-name" id="digits">digits</span> = &quot;<span class="string">0123456789</span>&quot;;
      <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">String</span> <span class="variable-name" id="hexchars">hexchars</span> = digits + &quot;<span class="string">abcdefABCDEF</span>&quot;;
  
      <span class="comment">/**
       * Return a boolean value indicating whether the argument is a
       * decimal digit (0-9).
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">c</span><span class="comment"> The character to check
       */</span>
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">boolean</span> <span class="function-name" id="isDigit">isDigit</span>(<span class="type">char</span> <span class="variable-name">c</span>) {
          <span class="keyword">return</span> digits.indexOf(c) &gt;= <span class="jde-java-font-lock-number">0</span>;
      }
  
      <span class="comment">/**
       * Return a boolean value indicating whether the argument is a
       * hexadecimal digit (0-9, A-F, a-f).
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">c</span><span class="comment"> The character to check
       */</span>
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">boolean</span> <span class="function-name" id="isHexDigit">isHexDigit</span>(<span class="type">char</span> <span class="variable-name">c</span>) {
          <span class="keyword">return</span> hexchars.indexOf(c) &gt;= <span class="jde-java-font-lock-number">0</span>;
      }
  
      <span class="comment">/**
       * Return a boolean value indicating whether the argument is whitespace
       * as defined by XSL (space, newline, CR, tab).
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">c</span><span class="comment"> The character to check
       */</span>
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">boolean</span> <span class="function-name" id="isSpace">isSpace</span>(<span class="type">char</span> <span class="variable-name">c</span>) {
          <span class="keyword">switch</span> (c) {
          <span class="keyword">case</span> '<span class="string"> </span>':
          <span class="keyword">case</span> '<span class="string">\r</span>':
          <span class="keyword">case</span> '<span class="string">\n</span>':
          <span class="keyword">case</span> '<span class="string">\t</span>':
              <span class="keyword">return</span> <span class="jde-java-font-lock-constant">true</span>;
          }
          <span class="keyword">return</span> <span class="jde-java-font-lock-constant">false</span>;
      }
  
      <span class="comment">/**
       * Return a  boolean value indicating whether the argument is a valid name
       * start character, ie. can start a NAME as defined by XSL.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">c</span><span class="comment"> The character to check
       */</span>
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">boolean</span> <span class="function-name" id="isNameStartChar">isNameStartChar</span>(<span class="type">char</span> <span class="variable-name">c</span>) {
          <span class="keyword">return</span> nameStartChars.indexOf(c) &gt;= <span class="jde-java-font-lock-number">0</span> || c &gt;= <span class="jde-java-font-lock-number">0x80</span>;
      }
  
      <span class="comment">/**
       * Return a  boolean value indicating whether the argument is a valid name
       * character, ie. can occur in a NAME as defined by XSL.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">c</span><span class="comment"> The character to check
       */</span>
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">boolean</span> <span class="function-name" id="isNameChar">isNameChar</span>(<span class="type">char</span> <span class="variable-name">c</span>) {
          <span class="keyword">return</span> nameStartChars.indexOf(c) &gt;= <span class="jde-java-font-lock-number">0</span> || nameChars.indexOf(c) &gt;= <span class="jde-java-font-lock-number">0</span>
                 || c &gt;= <span class="jde-java-font-lock-number">0x80</span>;
      }
  
  }
  </pre>
    </body>
  </html>
  
  
  
  1.1                  xml-site/targets/fop/design/alt.design/properties/PropertyValue.html
  
  Index: PropertyValue.html
  ===================================================================
  <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN">
  <!-- Created by htmlize-0.67 in css mode. -->
  <html>
    <head>
      <title>PropertyValue.java</title>
      <style type="text/css">
      <!--
        body {
          color: #000000;
          background-color: #faf0e6;
        } /* default */
        .jde-java-font-lock-package {
          color: #0000cd;
          background-color: #faf0e6;
        } /* jde-java-font-lock-package-face */
        .jde-java-font-lock-constant {
          color: #5f9ea0;
          background-color: #faf0e6;
        } /* jde-java-font-lock-constant-face */
        .keyword {
          color: #8b0000;
          background-color: #faf0e6;
        } /* font-lock-keyword-face */
        .jde-java-font-lock-doc-tag {
          color: #008b00;
          background-color: #faf0e6;
        } /* jde-java-font-lock-doc-tag-face */
        .jde-java-font-lock-number {
          color: #bc8f8f;
          background-color: #faf0e6;
        } /* jde-java-font-lock-number-face */
        .jde-java-font-lock-italic {
          background-color: #faf0e6;
          font-style: italic;
        } /* jde-java-font-lock-italic-face */
        .string {
          color: #008b00;
          background-color: #faf0e6;
        } /* font-lock-string-face */
        .variable-name {
          color: #8b008b;
          background-color: #faf0e6;
        } /* font-lock-variable-name-face */
        .jde-java-font-lock-modifier {
          color: #da70d6;
          background-color: #faf0e6;
        } /* jde-java-font-lock-modifier-face */
        .type {
          color: #4682b4;
          background-color: #faf0e6;
        } /* font-lock-type-face */
        .comment {
          color: #00008b;
          background-color: #faf0e6;
        } /* font-lock-comment-face */
        .function-name {
          color: #8b2323;
          background-color: #faf0e6;
        } /* font-lock-function-name-face */
        a {
          color: inherit;
          background-color: inherit;
          font: inherit;
          text-decoration: inherit;
        }
        a:hover {
          text-decoration: underline;
        }
      -->
      </style>
    </head>
    <body>
      <pre>
  <span class="keyword">package</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>;
  
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="jde-java-font-lock-package">expr</span>.<span class="type">PropertyException</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="type">FONode</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datastructs</span>.<span class="type">ROStringArray</span>;
  
  <span class="comment">/*
   * PropertyValue.java
   * $Id: PropertyValue.html,v 1.1 2003/01/24 10:46:48 pbwest Exp $
   *
   * Created: Tue Nov 20 22:18:11 2001
   * Copyright (C) 2001 The Apache Software Foundation. All rights reserved.
   * For details on use and redistribution please refer to the
   * LICENSE file included with these sources.
   * @author &lt;a href=&quot;mailto:pbwest@powerup.com.au&quot;&gt;Peter B. West&lt;/a&gt;
   * @version $Revision: 1.1 $ $Name:  $
   */</span>
  <span class="comment">/**
   * Base interface for all property value types.
   */</span>
  
  <span class="jde-java-font-lock-modifier">public</span> <span class="keyword">interface</span> <span class="function-name" id="PropertyValueInterface">PropertyValue</span> {
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span>
                          <span class="jde-java-font-lock-constant" id="NO_TYPE">NO_TYPE</span> = <span class="jde-java-font-lock-number">0</span>
                           ,<span class="jde-java-font-lock-constant" id="ANGLE">ANGLE</span> = <span class="jde-java-font-lock-number">1</span>
                            ,<span class="jde-java-font-lock-constant" id="AUTO">AUTO</span> = <span class="jde-java-font-lock-number">2</span>
                            ,<span class="jde-java-font-lock-constant" id="BOOL">BOOL</span> = <span class="jde-java-font-lock-number">3</span>
                      ,<span class="jde-java-font-lock-constant" id="COLOR_TYPE">COLOR_TYPE</span> = <span class="jde-java-font-lock-number">4</span>
                         ,<span class="jde-java-font-lock-constant" id="COUNTRY">COUNTRY</span> = <span class="jde-java-font-lock-number">5</span>
                            ,<span class="jde-java-font-lock-constant" id="ENUM">ENUM</span> = <span class="jde-java-font-lock-number">6</span>
                     ,<span class="jde-java-font-lock-constant" id="FONT_FAMILY">FONT_FAMILY</span> = <span class="jde-java-font-lock-number">7</span>
                       ,<span class="jde-java-font-lock-constant" id="FREQUENCY">FREQUENCY</span> = <span class="jde-java-font-lock-number">8</span>
          ,<span class="jde-java-font-lock-constant" id="FROM_NEAREST_SPECIFIED">FROM_NEAREST_SPECIFIED</span> = <span class="jde-java-font-lock-number">9</span>
                     ,<span class="jde-java-font-lock-constant" id="FROM_PARENT">FROM_PARENT</span> = <span class="jde-java-font-lock-number">10</span>
                         ,<span class="jde-java-font-lock-constant" id="INHERIT">INHERIT</span> = <span class="jde-java-font-lock-number">11</span>
                 ,<span class="jde-java-font-lock-constant" id="INHERITED_VALUE">INHERITED_VALUE</span> = <span class="jde-java-font-lock-number">12</span>
                         ,<span class="jde-java-font-lock-constant" id="INTEGER">INTEGER</span> = <span class="jde-java-font-lock-number">13</span>
                        ,<span class="jde-java-font-lock-constant" id="LANGUAGE">LANGUAGE</span> = <span class="jde-java-font-lock-number">14</span>
                         ,<span class="jde-java-font-lock-constant" id="LITERAL">LITERAL</span> = <span class="jde-java-font-lock-number">15</span>
                  ,<span class="jde-java-font-lock-constant" id="MAPPED_NUMERIC">MAPPED_NUMERIC</span> = <span class="jde-java-font-lock-number">16</span>
                       ,<span class="jde-java-font-lock-constant" id="MIME_TYPE">MIME_TYPE</span> = <span class="jde-java-font-lock-number">17</span>
                          ,<span class="jde-java-font-lock-constant" id="NCNAME">NCNAME</span> = <span class="jde-java-font-lock-number">18</span>
                            ,<span class="jde-java-font-lock-constant" id="NONE">NONE</span> = <span class="jde-java-font-lock-number">19</span>
                         ,<span class="jde-java-font-lock-constant" id="NUMERIC">NUMERIC</span> = <span class="jde-java-font-lock-number">20</span>
                          ,<span class="jde-java-font-lock-constant" id="SCRIPT">SCRIPT</span> = <span class="jde-java-font-lock-number">21</span>
                   ,<span class="jde-java-font-lock-constant" id="SHADOW_EFFECT">SHADOW_EFFECT</span> = <span class="jde-java-font-lock-number">22</span>
                           ,<span class="jde-java-font-lock-constant" id="SLASH">SLASH</span> = <span class="jde-java-font-lock-number">23</span>
                ,<span class="jde-java-font-lock-constant" id="TEXT_DECORATIONS">TEXT_DECORATIONS</span> = <span class="jde-java-font-lock-number">24</span>
                  ,<span class="jde-java-font-lock-constant" id="TEXT_DECORATOR">TEXT_DECORATOR</span> = <span class="jde-java-font-lock-number">25</span>
                            ,<span class="jde-java-font-lock-constant" id="TIME">TIME</span> = <span class="jde-java-font-lock-number">26</span>
                        ,<span class="jde-java-font-lock-constant" id="URI_TYPE">URI_TYPE</span> = <span class="jde-java-font-lock-number">27</span>
                            ,<span class="jde-java-font-lock-constant" id="LIST">LIST</span> = <span class="jde-java-font-lock-number">28</span>
  
              ,<span class="jde-java-font-lock-constant" id="LAST_PROPERTY_TYPE">LAST_PROPERTY_TYPE</span> = <span class="jde-java-font-lock-constant">LIST</span>;
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROStringArray</span> <span class="variable-name" id="propertyTypes">propertyTypes</span> =
          <span class="keyword">new</span> <span class="type">ROStringArray</span>(<span class="keyword">new</span> <span class="type">String</span>[] {
          &quot;<span class="string">NO_TYPE</span>&quot;
          ,&quot;<span class="string">ANGLE</span>&quot;
          ,&quot;<span class="string">AUTO</span>&quot;
          ,&quot;<span class="string">BOOL</span>&quot;
          ,&quot;<span class="string">COLOR_TYPE</span>&quot;
          ,&quot;<span class="string">COUNTRY</span>&quot;
          ,&quot;<span class="string">ENUM</span>&quot;
          ,&quot;<span class="string">FONT_FAMILY</span>&quot;
          ,&quot;<span class="string">FREQUENCY</span>&quot;
          ,&quot;<span class="string">FROM_NEAREST_SPECIFIED</span>&quot;
          ,&quot;<span class="string">FROM_PARENT</span>&quot;
          ,&quot;<span class="string">INHERIT</span>&quot;
          ,&quot;<span class="string">INHERITED_VALUE</span>&quot;
          ,&quot;<span class="string">INTEGER</span>&quot;
          ,&quot;<span class="string">LANGUAGE</span>&quot;
          ,&quot;<span class="string">LITERAL</span>&quot;
          ,&quot;<span class="string">MAPPED_NUMERIC</span>&quot;
          ,&quot;<span class="string">MIME_TYPE</span>&quot;
          ,&quot;<span class="string">NCNAME</span>&quot;
          ,&quot;<span class="string">NONE</span>&quot;
          ,&quot;<span class="string">NUMERIC</span>&quot;
          ,&quot;<span class="string">SCRIPT</span>&quot;
          ,&quot;<span class="string">SHADOW_EFFECT</span>&quot;
          ,&quot;<span class="string">SLASH</span>&quot;
          ,&quot;<span class="string">TEXT_DECORATIONS</span>&quot;
          ,&quot;<span class="string">TEXT_DECORATOR</span>&quot;
          ,&quot;<span class="string">TIME</span>&quot;
          ,&quot;<span class="string">URI_LIST</span>&quot;
          ,&quot;<span class="string">LIST</span>&quot;
      });
  
      <span class="comment">/**
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> &lt;tt&gt;int&lt;/tt&gt; property index.
       */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">int</span> <span class="function-name" id="getProperty">getProperty</span>();
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">void</span> <span class="function-name" id="setProperty">setProperty</span>(<span class="type">int</span> <span class="variable-name" id="index">index</span>) <span class="keyword">throws</span> <span class="type">PropertyException</span>;
  
      <span class="comment">/**
       * Get the &lt;tt&gt;int&lt;/tt&gt; type of property value.
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> type field of the &lt;tt&gt;PropertyValue&lt;/tt&gt;.
       */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">int</span> <span class="function-name" id="getType">getType</span>();
  
      <span class="comment">/**
       * In some circumstances, the property against which a type is to be
       * validated may not be the same as the property against which this
       * &lt;i&gt;</span><span class="jde-java-font-lock-italic">PropertyValue</span><span class="comment">&lt;/i&gt; is defined.  A specific property argument is
       * then required.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="testProperty">testProperty</span><span class="comment"> &lt;tt&gt;int&lt;/tt&gt; property index of the property
       * for which the type is to be validated.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="type">type</span><span class="comment"> &lt;tt&gt;int&lt;/tt&gt; bitmap of data types to check for
       * validity against this property.
       */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">void</span> <span class="function-name" id="validate">validate</span>(<span class="type">int</span> <span class="variable-name">testProperty</span>, <span class="type">int</span> <span class="variable-name">type</span>)
          <span class="keyword">throws</span> <span class="type">PropertyException</span>;
  
      <span class="comment">/**
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">type</span><span class="comment"> &lt;tt&gt;int&lt;/tt&gt; bitmap of data types to check for
       * validity against this property.
       */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">void</span> <span class="function-name">validate</span>(<span class="type">int</span> <span class="variable-name">type</span>) <span class="keyword">throws</span> <span class="type">PropertyException</span>;
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">Object</span> <span class="function-name" id="clone">clone</span>() <span class="keyword">throws</span> <span class="type">CloneNotSupportedException</span>;
  
  }
  </pre>
    </body>
  </html>
  
  
  
  1.1                  xml-site/targets/fop/design/alt.design/properties/PropertyValueList.html
  
  Index: PropertyValueList.html
  ===================================================================
  <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN">
  <!-- Created by htmlize-0.67 in css mode. -->
  <html>
    <head>
      <title>PropertyValueList.java</title>
      <style type="text/css">
      <!--
        body {
          color: #000000;
          background-color: #faf0e6;
        } /* default */
        .jde-java-font-lock-package {
          color: #0000cd;
          background-color: #faf0e6;
        } /* jde-java-font-lock-package-face */
        .jde-java-font-lock-constant {
          color: #5f9ea0;
          background-color: #faf0e6;
        } /* jde-java-font-lock-constant-face */
        .keyword {
          color: #8b0000;
          background-color: #faf0e6;
        } /* font-lock-keyword-face */
        .jde-java-font-lock-doc-tag {
          color: #008b00;
          background-color: #faf0e6;
        } /* jde-java-font-lock-doc-tag-face */
        .jde-java-font-lock-number {
          color: #bc8f8f;
          background-color: #faf0e6;
        } /* jde-java-font-lock-number-face */
        .jde-java-font-lock-italic {
          background-color: #faf0e6;
          font-style: italic;
        } /* jde-java-font-lock-italic-face */
        .string {
          color: #008b00;
          background-color: #faf0e6;
        } /* font-lock-string-face */
        .variable-name {
          color: #8b008b;
          background-color: #faf0e6;
        } /* font-lock-variable-name-face */
        .jde-java-font-lock-modifier {
          color: #da70d6;
          background-color: #faf0e6;
        } /* jde-java-font-lock-modifier-face */
        .type {
          color: #4682b4;
          background-color: #faf0e6;
        } /* font-lock-type-face */
        .comment {
          color: #00008b;
          background-color: #faf0e6;
        } /* font-lock-comment-face */
        .function-name {
          color: #8b2323;
          background-color: #faf0e6;
        } /* font-lock-function-name-face */
        a {
          color: inherit;
          background-color: inherit;
          font: inherit;
          text-decoration: inherit;
        }
        a:hover {
          text-decoration: underline;
        }
      -->
      </style>
    </head>
    <body>
      <pre>
  <span class="keyword">package</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>;
  
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">java</span>.<span class="jde-java-font-lock-package">lang</span>.<span class="jde-java-font-lock-package">reflect</span>.<span class="type">InvocationTargetException</span>;
  
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">java</span>.<span class="jde-java-font-lock-package">util</span>.<span class="type">LinkedList</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">java</span>.<span class="jde-java-font-lock-package">util</span>.<span class="type">Collection</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">java</span>.<span class="jde-java-font-lock-package">util</span>.<span class="type">Iterator</span>;
  
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="jde-java-font-lock-package">properties</span>.<span class="jde-java-font-lock-number">*</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="type">PropertyConsts</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="type">PropNames</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="type">FONode</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">PropertyValue</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="jde-java-font-lock-package">expr</span>.<span class="type">PropertyException</span>;
  
  <span class="comment">/*
   * PropertyValueList.java
   * $Id: PropertyValueList.html,v 1.1 2003/01/24 10:46:48 pbwest Exp $
   *
   * Created: Tue Dec 11 22:37:16 2001
   * Copyright (C) 2001 The Apache Software Foundation. All rights reserved.
   * For details on use and redistribution please refer to the
   * LICENSE file included with these sources.
   * @author &lt;a href=&quot;mailto:pbwest@powerup.com.au&quot;&gt;Peter B. West&lt;/a&gt;
   * @version $Revision: 1.1 $ $Name:  $
   */</span>
  <span class="comment">/**
   * A list of &lt;tt&gt;PropertyValue&lt;/tt&gt; elements.
   */</span>
  
  <span class="jde-java-font-lock-modifier">public</span> <span class="keyword">class</span> <span class="function-name" id="PropertyValueListClass">PropertyValueList</span> <span class="keyword">extends</span> <span class="type">LinkedList</span> <span class="keyword">implements</span> <span class="type">PropertyValue</span> {
  
      <span class="comment">/**
       * An integer index to the type of property of which this is a value.
       */</span>
      <span class="jde-java-font-lock-modifier">protected</span> <span class="type">int</span> <span class="variable-name" id="property">property</span>;
  
      <span class="comment">/**
       * An integer property type.
       */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span> <span class="variable-name" id="type">type</span>;
  
      <span class="comment">/**
       * The PropertyConsts singleton.
       */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">PropertyConsts</span> <span class="variable-name" id="propertyConsts">propertyConsts</span>;
  
      <span class="comment">/**
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">property</span><span class="comment"> &lt;tt&gt;int&lt;/tt&gt; index of the property.
       */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="function-name" id="PropertyValueList">PropertyValueList</span>(<span class="type">int</span> <span class="variable-name">property</span>) <span class="keyword">throws</span> <span class="type">PropertyException</span> {
          <span class="keyword">super</span>();
          <span class="keyword">if</span> (property &lt; <span class="jde-java-font-lock-number">1</span> || property &gt; PropNames.<span class="jde-java-font-lock-constant" id="LAST_PROPERTY_INDEX">LAST_PROPERTY_INDEX</span>)
              <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(&quot;<span class="string">Invalid property index: </span>&quot; + property);
          <span class="keyword">this</span>.property = property;
          type = PropertyValue.<span class="jde-java-font-lock-constant" id="LIST">LIST</span>;
          propertyConsts = PropertyConsts.getPropertyConsts();
      }
  
      <span class="comment">/**
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="propertyName">propertyName</span><span class="comment"> a &lt;tt&gt;String&lt;/tt&gt; containing the property name.
       */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="function-name">PropertyValueList</span>(<span class="type">String</span> <span class="variable-name">propertyName</span>)
          <span class="keyword">throws</span> <span class="type">PropertyException</span>
      {
          <span class="keyword">super</span>();
          property = PropNames.getPropertyIndex(propertyName);
          <span class="keyword">if</span> (property &lt; <span class="jde-java-font-lock-number">1</span> || property &gt; PropNames.<span class="jde-java-font-lock-constant">LAST_PROPERTY_INDEX</span>)
              <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(&quot;<span class="string">Invalid property index: </span>&quot; + property);
          type = PropertyValue.<span class="jde-java-font-lock-constant">LIST</span>;
          propertyConsts = PropertyConsts.getPropertyConsts();
      }
  
      <span class="comment">/**
       * Constructor with a &lt;tt&gt;Collection&lt;/tt&gt;.  Pass through to superclass
       * only if the collection is another instance of a PropertyValueList.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">property</span><span class="comment"> &lt;tt&gt;int&lt;/tt&gt; index of the property.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="c">c</span><span class="comment"> a &lt;tt&gt;Collection&lt;/tt&gt;, which must be another
       * &lt;i&gt;</span><span class="jde-java-font-lock-italic">PropertyValueList</span><span class="comment">&lt;/i&gt;.
       * </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">IllegalArgumentException</span><span class="comment"> if the &lt;tt&gt;Collection&lt;/tt&gt; is
       * not a &lt;i&gt;</span><span class="jde-java-font-lock-italic">PropertyValueList</span><span class="comment">&lt;/i&gt;.
       */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="function-name">PropertyValueList</span>(<span class="type">int</span> <span class="variable-name">property</span>, <span class="type">Collection</span> <span class="variable-name">c</span>)
          <span class="keyword">throws</span> <span class="type">PropertyException</span>
      {
          <span class="keyword">super</span>(c);
          <span class="comment">// This test only follows the super() call because that call must
  </span>        <span class="comment">// be the first in a constructor.
  </span>        <span class="keyword">if</span> (! (c <span class="keyword">instanceof</span> <span class="type">PropertyValueList</span>))
              <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">IllegalArgumentException</span>
                      (&quot;<span class="string">Collection is not a PropertyValueList.</span>&quot;);
          <span class="keyword">if</span> (property &lt; <span class="jde-java-font-lock-number">1</span> || property &gt; PropNames.<span class="jde-java-font-lock-constant">LAST_PROPERTY_INDEX</span>)
              <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(&quot;<span class="string">Invalid property index: </span>&quot; + property);
          <span class="keyword">this</span>.property = property;
          type = PropertyValue.<span class="jde-java-font-lock-constant">LIST</span>;
          propertyConsts = PropertyConsts.getPropertyConsts();
      }
  
      <span class="comment">/**
       * Constructor with a &lt;tt&gt;Collection&lt;/tt&gt;.  Pass through to superclass
       * only if the collection is another instance of a PropertyValueList.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">propertyName</span><span class="comment"> a &lt;tt&gt;String&lt;/tt&gt; containing the property name.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">c</span><span class="comment"> a &lt;tt&gt;Collection&lt;/tt&gt;, which must be another
       * &lt;i&gt;</span><span class="jde-java-font-lock-italic">PropertyValueList</span><span class="comment">&lt;/i&gt;.
       * </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">IllegalArgumentException</span><span class="comment"> if the &lt;tt&gt;Collection&lt;/tt&gt; is
       * not a &lt;i&gt;</span><span class="jde-java-font-lock-italic">PropertyValueList</span><span class="comment">&lt;/i&gt;.
       */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="function-name">PropertyValueList</span>(<span class="type">String</span> <span class="variable-name">propertyName</span>, <span class="type">Collection</span> <span class="variable-name">c</span>)
          <span class="keyword">throws</span> <span class="type">PropertyException</span>
      {
          <span class="keyword">super</span>(c);
          <span class="comment">// This test only follows the super() call because that call must
  </span>        <span class="comment">// be the first in a constructor.
  </span>        <span class="keyword">if</span> (! (c <span class="keyword">instanceof</span> <span class="type">PropertyValueList</span>))
              <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">IllegalArgumentException</span>
                      (&quot;<span class="string">Collection is not a PropertyValueList.</span>&quot;);
          property = PropNames.getPropertyIndex(propertyName);
          <span class="keyword">if</span> (property &lt; <span class="jde-java-font-lock-number">1</span> || property &gt; PropNames.<span class="jde-java-font-lock-constant">LAST_PROPERTY_INDEX</span>)
              <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(&quot;<span class="string">Invalid property index: </span>&quot; + property);
          type = PropertyValue.<span class="jde-java-font-lock-constant">LIST</span>;
          propertyConsts = PropertyConsts.getPropertyConsts();
      }
  
      <span class="comment">/**
       * Append a PropertyValue or PropertyValueList to the end of the list.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="o">o</span><span class="comment"> a &lt;tt&gt;PropertyValue&lt;/tt&gt; or a &lt;PropertyValueList&lt;/tt&gt;;
       * the element to add.  Defined as an
       * &lt;tt&gt;Object&lt;/tt&gt; to override the definition in &lt;tt&gt;LinkedList&lt;/tt&gt;.
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> a &lt;tt&gt;boolean&lt;/tt&gt; success or failure(?).
       * </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">IllegalArgumentException</span><span class="comment"> if the object is not a
       * &lt;tt&gt;PropertyValue&lt;/tt&gt; or &lt;tt&gt;PropertyValueList&lt;/tt&gt;.
       */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">boolean</span> <span class="function-name" id="add">add</span>(<span class="type">Object</span> <span class="variable-name">o</span>) {
          <span class="keyword">if</span> (! (o <span class="keyword">instanceof</span> <span class="type">PropertyValue</span> || o <span class="keyword">instanceof</span> <span class="type">PropertyValueList</span>))
              <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">IllegalArgumentException</span>
                      (&quot;<span class="string">Object is not a PropertyValue or a PropertyValueList.</span>&quot;);
          <span class="keyword">return</span> <span class="keyword">super</span>.add(o);
      }
  
      <span class="comment">/**
       * Insert a &lt;tt&gt;PropertyValue&lt;/tt&gt; or &lt;tt&gt;PropertyValueList&lt;/tt&gt;
       * at the beginning of the list.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">o</span><span class="comment"> a &lt;tt&gt;PropertyValue&lt;/tt&gt; or a &lt;PropertyValueList&lt;/tt&gt;;
       * the element to add.  Defined as an
       * &lt;tt&gt;Object&lt;/tt&gt; to override the definition in &lt;tt&gt;LinkedList&lt;/tt&gt;.
       * </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">IllegalArgumentException</span><span class="comment"> if the object is not a
       * &lt;tt&gt;PropertyValue&lt;/tt&gt; or &lt;tt&gt;PropertyValueList&lt;/tt&gt;.
       */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">void</span> <span class="function-name" id="addFirst">addFirst</span>(<span class="type">Object</span> <span class="variable-name">o</span>) {
          <span class="keyword">if</span> (! (o <span class="keyword">instanceof</span> <span class="type">PropertyValue</span> || o <span class="keyword">instanceof</span> <span class="type">PropertyValueList</span>))
              <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">IllegalArgumentException</span>
                      (&quot;<span class="string">Object is not a PropertyValue or a PropertyValueList.</span>&quot;);
          <span class="keyword">super</span>.addFirst(o);
      }
  
      <span class="comment">/**
       * Append a PropertyValue to the end of the list.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">o</span><span class="comment"> a &lt;tt&gt;PropertyValue&lt;/tt&gt;; the element to add.  Defined as an
       * &lt;tt&gt;Object&lt;/tt&gt; to override the definition in &lt;tt&gt;LinkedList&lt;/tt&gt;.
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> a &lt;tt&gt;boolean&lt;/tt&gt; success or failure(?).
       * </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">IllegalArgumentException</span><span class="comment"> if the object is not a
       * &lt;tt&gt;PropertyValue&lt;/tt&gt;.
       */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">void</span> <span class="function-name" id="addLast">addLast</span>(<span class="type">Object</span> <span class="variable-name">o</span>) {
          add(o);
      }
  
      <span class="comment">/*
       * Following fields and methods implement the PropertyValue interface
       */</span>
  
      <span class="comment">/**
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> &lt;tt&gt;int&lt;/tt&gt; property index.
       */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">int</span> <span class="function-name" id="getProperty">getProperty</span>() {
          <span class="keyword">return</span> property;
      }
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">void</span> <span class="function-name" id="setProperty">setProperty</span>(<span class="type">int</span> <span class="variable-name" id="index">index</span>) <span class="keyword">throws</span> <span class="type">PropertyException</span> {
          <span class="keyword">if</span> (index &lt; <span class="jde-java-font-lock-number">0</span> || index &gt; PropNames.<span class="jde-java-font-lock-constant">LAST_PROPERTY_INDEX</span>)
              <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(&quot;<span class="string">Invalid property index: </span>&quot; + index);
          property = index;
      }
  
      <span class="comment">/**
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> type field of the &lt;tt&gt;PropertyValue&lt;/tt&gt;.
       */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">int</span> <span class="function-name" id="getType">getType</span>() {
          <span class="keyword">return</span> type;
      }
  
      <span class="comment">/**
       * In some circumstances, the property against which a type is to be
       * validated may not be the same as the property against which this
       * &lt;i&gt;</span><span class="jde-java-font-lock-italic">AbstractPropertyValue</span><span class="comment">&lt;/i&gt; is defined.
       * A specific property argument is then required.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="testProperty">testProperty</span><span class="comment"> &lt;tt&gt;int&lt;/tt&gt; property index of the property
       * for which the type is to be validated.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">type</span><span class="comment"> &lt;tt&gt;int&lt;/tt&gt; bitmap of data types to check for
       * validity against this property.
       */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">void</span> <span class="function-name" id="validate">validate</span>(<span class="type">int</span> <span class="variable-name">testProperty</span>, <span class="type">int</span> <span class="variable-name">type</span>)
          <span class="keyword">throws</span> <span class="type">PropertyException</span>
      {
          <span class="comment">// N.B. PROPERTY_SPECIFIC inheritance may require more specialized
  </span>        <span class="comment">// checks.  Only line-height comes into this category.
  </span>
          <span class="comment">// N.B. The first commented-out condition means that I cannot validate
  </span>        <span class="comment">// unless the property is NOT inherited.
  </span>        <span class="comment">// I can't remember why I put this
  </span>        <span class="comment">// condition in here.  Removing it.  pbw 2002/02/18
  </span>        <span class="comment">//if (propertyConsts.inherited.get(testProperty) == Property.NO
  </span>        <span class="comment">//&amp;&amp; (propertyConsts.getDataTypes(testProperty) &amp; type) == 0) {
  </span>
              <span class="keyword">if</span> ((propertyConsts.getDataTypes(testProperty) &amp; type) == <span class="jde-java-font-lock-number">0</span>) {
              <span class="type">String</span> <span class="variable-name" id="pname">pname</span> = PropNames.getPropertyName(testProperty);
              <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>
                      (&quot;<span class="string">Datatype(s) </span>&quot; +
                       Property.listDataTypes(type) +
                       &quot;<span class="string"> not defined on </span>&quot; + pname);
          }
      }
  
      <span class="comment">/**
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">type</span><span class="comment"> &lt;tt&gt;int&lt;/tt&gt; bitmap of data types to check for
       * validity against this property.
       */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">void</span> <span class="function-name">validate</span>(<span class="type">int</span> <span class="variable-name">type</span>) <span class="keyword">throws</span> <span class="type">PropertyException</span> {
          <span class="comment">// N.B. PROPERTY_SPECIFIC inheritance may require more specialized
  </span>        <span class="comment">// checks.  Only line-height comes into this category.
  </span>        validate(property, type);
      }
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">String</span> <span class="function-name" id="toString">toString</span>() {
          <span class="type">String</span> <span class="variable-name" id="str">str</span>, <span class="variable-name">cstr</span>;
          <span class="keyword">try</span> {
              str = &quot;<span class="string">Property: </span>&quot; + PropNames.getPropertyName(property)
                      + &quot;<span class="string"> Index: </span>&quot; + property + &quot;<span class="string"> List contents:\n</span>&quot;;
              <span class="type">Iterator</span> <span class="variable-name" id="contents">contents</span> = iterator();
              <span class="keyword">while</span> (contents.hasNext()) {
                  <span class="type">int</span> <span class="variable-name" id="i">i</span> = <span class="jde-java-font-lock-number">0</span>, <span class="variable-name">j</span> = <span class="jde-java-font-lock-number">0</span>;
                  <span class="type">Object</span> <span class="variable-name" id="obj">obj</span> = contents.next();
                  <span class="keyword">try</span> {
                      cstr = (<span class="type">String</span>)(obj.getClass()
                                  .getMethod(&quot;<span class="string">toString</span>&quot;, <span class="jde-java-font-lock-constant" id="null">null</span>)
                                  .invoke(obj, <span class="jde-java-font-lock-constant">null</span>));
                  } <span class="keyword">catch</span> (<span class="type">IllegalAccessException</span> <span class="variable-name" id="e">e</span>) {
                      <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span> (e);
                  } <span class="keyword">catch</span> (<span class="type">NoSuchMethodException</span> <span class="variable-name">e</span>) {
                      <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span> (e);
                  } <span class="keyword">catch</span> (<span class="type">InvocationTargetException</span> <span class="variable-name">e</span>) {
                      <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span> (e);
                  }
                  <span class="keyword">while</span> (i &lt; cstr.length() &amp;&amp; j &gt;= <span class="jde-java-font-lock-number">0</span>) {
                      j = cstr.indexOf('<span class="string">\n</span>', j);
                      <span class="keyword">if</span> (j &gt;= <span class="jde-java-font-lock-number">0</span>) {
                          str = str + &quot;<span class="string">&gt;</span>&quot; + cstr.substring(i, ++j);
                          i = j;
                      } <span class="keyword">else</span> {
                          str = str + &quot;<span class="string">&gt;</span>&quot; + cstr.substring(i);
                          i = cstr.length();
                      }
                  }
              }
              <span class="keyword">return</span> str;
  
          } <span class="keyword">catch</span> (<span class="type">PropertyException</span> <span class="variable-name">e</span>) {
              <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">RuntimeException</span>(e.getMessage());
          }
      }
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">Object</span> <span class="function-name" id="clone">clone</span>() {
          <span class="keyword">return</span> <span class="keyword">super</span>.clone();
      }
  
  }<span class="comment">// PropertyValueList
  </span></pre>
    </body>
  </html>
  
  
  
  1.1                  xml-site/targets/fop/design/alt.design/properties/PropNames.html
  
  Index: PropNames.html
  ===================================================================
  <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN">
  <!-- Created by htmlize-0.67 in css mode. -->
  <html>
    <head>
      <title>PropNames.java</title>
      <style type="text/css">
      <!--
        body {
          color: #000000;
          background-color: #faf0e6;
        } /* default */
        .function-name {
          color: #8b2323;
          background-color: #faf0e6;
        } /* font-lock-function-name-face */
        .jde-java-font-lock-italic {
          background-color: #faf0e6;
          font-style: italic;
        } /* jde-java-font-lock-italic-face */
        .jde-java-font-lock-modifier {
          color: #da70d6;
          background-color: #faf0e6;
        } /* jde-java-font-lock-modifier-face */
        .keyword {
          color: #8b0000;
          background-color: #faf0e6;
        } /* font-lock-keyword-face */
        .variable-name {
          color: #8b008b;
          background-color: #faf0e6;
        } /* font-lock-variable-name-face */
        .string {
          color: #008b00;
          background-color: #faf0e6;
        } /* font-lock-string-face */
        .jde-java-font-lock-package {
          color: #0000cd;
          background-color: #faf0e6;
        } /* jde-java-font-lock-package-face */
        .jde-java-font-lock-constant {
          color: #5f9ea0;
          background-color: #faf0e6;
        } /* jde-java-font-lock-constant-face */
        .type {
          color: #4682b4;
          background-color: #faf0e6;
        } /* font-lock-type-face */
        .jde-java-font-lock-doc-tag {
          color: #008b00;
          background-color: #faf0e6;
        } /* jde-java-font-lock-doc-tag-face */
        .comment {
          color: #00008b;
          background-color: #faf0e6;
        } /* font-lock-comment-face */
        .jde-java-font-lock-number {
          color: #bc8f8f;
          background-color: #faf0e6;
        } /* jde-java-font-lock-number-face */
        a {
          color: inherit;
          background-color: inherit;
          font: inherit;
          text-decoration: inherit;
        }
        a:hover {
          text-decoration: underline;
        }
      -->
      </style>
    </head>
    <body>
      <pre>
  <span class="comment">/*
   * $Id: PropNames.html,v 1.1 2003/01/24 10:46:48 pbwest Exp $
   * Copyright (C) 2001-2002 The Apache Software Foundation. All rights reserved.
   * For details on use and redistribution please refer to the
   * LICENSE file included with these sources.
   * @author &lt;a href=&quot;mailto:pbwest@powerup.com.au&quot;&gt;Peter B. West&lt;/a&gt;
   * @version $Revision: 1.1 $ $Name:  $
   */</span>
  
  <span class="keyword">package</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>;
  
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">java</span>.<span class="jde-java-font-lock-package">util</span>.<span class="type">HashMap</span>;
  
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="jde-java-font-lock-package">expr</span>.<span class="type">PropertyException</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">Ints</span>;
  
  <span class="comment">/**
   * A class of constants; an array of all property names and the constants
   * by which to refer to them.
   */</span>
  
  <span class="jde-java-font-lock-modifier">public</span> <span class="keyword">class</span> <span class="function-name" id="PropNamesClass">PropNames</span> {
  
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">String</span> <span class="variable-name" id="tag">tag</span> = &quot;<span class="string">$Name:  $</span>&quot;;
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">String</span> <span class="variable-name" id="revision">revision</span> = &quot;<span class="string">$Revision: 1.1 $</span>&quot;;
  
      <span class="comment">/*
       * List of property constants in property processing order -
       * FONT, FONT_SIZE first
       * Shorthands must precede any of their expansion elements.
       * Compounds must precede any of their components.
       * The list of property constants can be regenerated in XEmacs by setting
       * the region on the list of constants. (C-Space at the beginning,
       * move to last line, C-x C-x to exchange mark and point.)  Then run
       * a shell command on the region with replacement (M-1 M-|).  Use
       * the perl command:
       * perl -p -e 'BEGIN{$n=0};$n++ if s/= [0-9]+,/= $n,/'
       * Alternatively, start at a given point in the list by setting the
       * appropriate start value for $n.
       *
       * in vi, set mark `</span><span class="jde-java-font-lock-doc-tag">a</span><span class="comment">' at the last line and
       * !'aperl... etc
       */</span>
       <span class="comment">/** Constant for matching property defined in &lt;i&gt;</span><span class="jde-java-font-lock-italic">XSLFO</span><span class="comment">&lt;/i&gt;. */</span>
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span>
                                      <span class="jde-java-font-lock-constant" id="NO_PROPERTY">NO_PROPERTY</span> = <span class="jde-java-font-lock-number">0</span>,
              <span class="comment">// Properties setting up environment for from-table-column(),
  </span>            <span class="comment">// e.g. font-size = from-table-column()
  </span>                                  <span class="jde-java-font-lock-constant" id="COLUMN_NUMBER">COLUMN_NUMBER</span> = <span class="jde-java-font-lock-number">1</span>,
                           <span class="jde-java-font-lock-constant" id="NUMBER_COLUMNS_SPANNED">NUMBER_COLUMNS_SPANNED</span> = <span class="jde-java-font-lock-number">2</span>,
              <span class="comment">// Properties setting font-size first
  </span>            <span class="comment">// Shorthand first
  </span>                                           <span class="jde-java-font-lock-constant" id="FONT">FONT</span> = <span class="jde-java-font-lock-number">3</span>,
                                        <span class="jde-java-font-lock-constant" id="FONT_SIZE">FONT_SIZE</span> = <span class="jde-java-font-lock-number">4</span>,
              <span class="comment">// Writing mode early for handling of corresponding values
  </span>                                   <span class="jde-java-font-lock-constant" id="WRITING_MODE">WRITING_MODE</span> = <span class="jde-java-font-lock-number">5</span>,
              <span class="comment">// All other shorthands
  </span>                                     <span class="jde-java-font-lock-constant" id="BACKGROUND">BACKGROUND</span> = <span class="jde-java-font-lock-number">6</span>,
                              <span class="jde-java-font-lock-constant" id="BACKGROUND_POSITION">BACKGROUND_POSITION</span> = <span class="jde-java-font-lock-number">7</span>,
                                           <span class="jde-java-font-lock-constant" id="BORDER">BORDER</span> = <span class="jde-java-font-lock-number">8</span>,
                                     <span class="jde-java-font-lock-constant" id="BORDER_COLOR">BORDER_COLOR</span> = <span class="jde-java-font-lock-number">9</span>,
                                     <span class="jde-java-font-lock-constant" id="BORDER_STYLE">BORDER_STYLE</span> = <span class="jde-java-font-lock-number">10</span>,
                                     <span class="jde-java-font-lock-constant" id="BORDER_WIDTH">BORDER_WIDTH</span> = <span class="jde-java-font-lock-number">11</span>,
                                    <span class="jde-java-font-lock-constant" id="BORDER_BOTTOM">BORDER_BOTTOM</span> = <span class="jde-java-font-lock-number">12</span>,
                                      <span class="jde-java-font-lock-constant" id="BORDER_LEFT">BORDER_LEFT</span> = <span class="jde-java-font-lock-number">13</span>,
                                     <span class="jde-java-font-lock-constant" id="BORDER_RIGHT">BORDER_RIGHT</span> = <span class="jde-java-font-lock-number">14</span>,
                                       <span class="jde-java-font-lock-constant" id="BORDER_TOP">BORDER_TOP</span> = <span class="jde-java-font-lock-number">15</span>,
                                   <span class="jde-java-font-lock-constant" id="BORDER_SPACING">BORDER_SPACING</span> = <span class="jde-java-font-lock-number">16</span>,
                                              <span class="jde-java-font-lock-constant" id="CUE">CUE</span> = <span class="jde-java-font-lock-number">17</span>,
                                           <span class="jde-java-font-lock-constant" id="MARGIN">MARGIN</span> = <span class="jde-java-font-lock-number">18</span>,
                                          <span class="jde-java-font-lock-constant" id="PADDING">PADDING</span> = <span class="jde-java-font-lock-number">19</span>,
                                 <span class="jde-java-font-lock-constant" id="PAGE_BREAK_AFTER">PAGE_BREAK_AFTER</span> = <span class="jde-java-font-lock-number">20</span>,
                                <span class="jde-java-font-lock-constant" id="PAGE_BREAK_BEFORE">PAGE_BREAK_BEFORE</span> = <span class="jde-java-font-lock-number">21</span>,
                                <span class="jde-java-font-lock-constant" id="PAGE_BREAK_INSIDE">PAGE_BREAK_INSIDE</span> = <span class="jde-java-font-lock-number">22</span>,
                                            <span class="jde-java-font-lock-constant" id="PAUSE">PAUSE</span> = <span class="jde-java-font-lock-number">23</span>,
                                         <span class="jde-java-font-lock-constant" id="POSITION">POSITION</span> = <span class="jde-java-font-lock-number">24</span>,
                                             <span class="jde-java-font-lock-constant" id="SIZE">SIZE</span> = <span class="jde-java-font-lock-number">25</span>,
                                   <span class="jde-java-font-lock-constant" id="VERTICAL_ALIGN">VERTICAL_ALIGN</span> = <span class="jde-java-font-lock-number">26</span>,
                                      <span class="jde-java-font-lock-constant" id="WHITE_SPACE">WHITE_SPACE</span> = <span class="jde-java-font-lock-number">27</span>,
                                         <span class="jde-java-font-lock-constant" id="XML_LANG">XML_LANG</span> = <span class="jde-java-font-lock-number">28</span>,
              <span class="comment">// Non-shorthand properties
  </span>            <span class="comment">// Within these, compounds precede their components
  </span>            <span class="comment">// and corresponding relative properties
  </span>            <span class="comment">// precede corresponding absolute properties
  </span>                              <span class="jde-java-font-lock-constant" id="ABSOLUTE_POSITION">ABSOLUTE_POSITION</span> = <span class="jde-java-font-lock-number">29</span>,
                                     <span class="jde-java-font-lock-constant" id="ACTIVE_STATE">ACTIVE_STATE</span> = <span class="jde-java-font-lock-number">30</span>,
                                 <span class="jde-java-font-lock-constant" id="ALIGNMENT_ADJUST">ALIGNMENT_ADJUST</span> = <span class="jde-java-font-lock-number">31</span>,
                               <span class="jde-java-font-lock-constant" id="ALIGNMENT_BASELINE">ALIGNMENT_BASELINE</span> = <span class="jde-java-font-lock-number">32</span>,
                                     <span class="jde-java-font-lock-constant" id="AUTO_RESTORE">AUTO_RESTORE</span> = <span class="jde-java-font-lock-number">33</span>,
                                          <span class="jde-java-font-lock-constant" id="AZIMUTH">AZIMUTH</span> = <span class="jde-java-font-lock-number">34</span>,
                            <span class="jde-java-font-lock-constant" id="BACKGROUND_ATTACHMENT">BACKGROUND_ATTACHMENT</span> = <span class="jde-java-font-lock-number">35</span>,
                                 <span class="jde-java-font-lock-constant" id="BACKGROUND_COLOR">BACKGROUND_COLOR</span> = <span class="jde-java-font-lock-number">36</span>,
                                 <span class="jde-java-font-lock-constant" id="BACKGROUND_IMAGE">BACKGROUND_IMAGE</span> = <span class="jde-java-font-lock-number">37</span>,
                   <span class="jde-java-font-lock-constant" id="BACKGROUND_POSITION_HORIZONTAL">BACKGROUND_POSITION_HORIZONTAL</span> = <span class="jde-java-font-lock-number">38</span>,
                     <span class="jde-java-font-lock-constant" id="BACKGROUND_POSITION_VERTICAL">BACKGROUND_POSITION_VERTICAL</span> = <span class="jde-java-font-lock-number">39</span>,
                                <span class="jde-java-font-lock-constant" id="BACKGROUND_REPEAT">BACKGROUND_REPEAT</span> = <span class="jde-java-font-lock-number">40</span>,
                                   <span class="jde-java-font-lock-constant" id="BASELINE_SHIFT">BASELINE_SHIFT</span> = <span class="jde-java-font-lock-number">41</span>,
                               <span class="jde-java-font-lock-constant" id="BLANK_OR_NOT_BLANK">BLANK_OR_NOT_BLANK</span> = <span class="jde-java-font-lock-number">42</span>,
                      <span class="jde-java-font-lock-constant" id="BLOCK_PROGRESSION_DIMENSION">BLOCK_PROGRESSION_DIMENSION</span> = <span class="jde-java-font-lock-number">43</span>,
              <span class="jde-java-font-lock-constant" id="BLOCK_PROGRESSION_DIMENSION_MINIMUM">BLOCK_PROGRESSION_DIMENSION_MINIMUM</span> = <span class="jde-java-font-lock-number">44</span>,
              <span class="jde-java-font-lock-constant" id="BLOCK_PROGRESSION_DIMENSION_OPTIMUM">BLOCK_PROGRESSION_DIMENSION_OPTIMUM</span> = <span class="jde-java-font-lock-number">45</span>,
              <span class="jde-java-font-lock-constant" id="BLOCK_PROGRESSION_DIMENSION_MAXIMUM">BLOCK_PROGRESSION_DIMENSION_MAXIMUM</span> = <span class="jde-java-font-lock-number">46</span>,
  
          <span class="comment">// Border corresponding properties
  </span>                             <span class="jde-java-font-lock-constant" id="BORDER_AFTER_COLOR">BORDER_AFTER_COLOR</span> = <span class="jde-java-font-lock-number">47</span>,
                          <span class="jde-java-font-lock-constant" id="BORDER_AFTER_PRECEDENCE">BORDER_AFTER_PRECEDENCE</span> = <span class="jde-java-font-lock-number">48</span>,
                               <span class="jde-java-font-lock-constant" id="BORDER_AFTER_STYLE">BORDER_AFTER_STYLE</span> = <span class="jde-java-font-lock-number">49</span>,
                               <span class="jde-java-font-lock-constant" id="BORDER_AFTER_WIDTH">BORDER_AFTER_WIDTH</span> = <span class="jde-java-font-lock-number">50</span>,
                        <span class="jde-java-font-lock-constant" id="BORDER_AFTER_WIDTH_LENGTH">BORDER_AFTER_WIDTH_LENGTH</span> = <span class="jde-java-font-lock-number">51</span>,
                <span class="jde-java-font-lock-constant" id="BORDER_AFTER_WIDTH_CONDITIONALITY">BORDER_AFTER_WIDTH_CONDITIONALITY</span> = <span class="jde-java-font-lock-number">52</span>,
                              <span class="jde-java-font-lock-constant" id="BORDER_BEFORE_COLOR">BORDER_BEFORE_COLOR</span> = <span class="jde-java-font-lock-number">53</span>,
                         <span class="jde-java-font-lock-constant" id="BORDER_BEFORE_PRECEDENCE">BORDER_BEFORE_PRECEDENCE</span> = <span class="jde-java-font-lock-number">54</span>,
                              <span class="jde-java-font-lock-constant" id="BORDER_BEFORE_STYLE">BORDER_BEFORE_STYLE</span> = <span class="jde-java-font-lock-number">55</span>,
                              <span class="jde-java-font-lock-constant" id="BORDER_BEFORE_WIDTH">BORDER_BEFORE_WIDTH</span> = <span class="jde-java-font-lock-number">56</span>,
                       <span class="jde-java-font-lock-constant" id="BORDER_BEFORE_WIDTH_LENGTH">BORDER_BEFORE_WIDTH_LENGTH</span> = <span class="jde-java-font-lock-number">57</span>,
               <span class="jde-java-font-lock-constant" id="BORDER_BEFORE_WIDTH_CONDITIONALITY">BORDER_BEFORE_WIDTH_CONDITIONALITY</span> = <span class="jde-java-font-lock-number">58</span>,
                                 <span class="jde-java-font-lock-constant" id="BORDER_END_COLOR">BORDER_END_COLOR</span> = <span class="jde-java-font-lock-number">59</span>,
                            <span class="jde-java-font-lock-constant" id="BORDER_END_PRECEDENCE">BORDER_END_PRECEDENCE</span> = <span class="jde-java-font-lock-number">60</span>,
                                 <span class="jde-java-font-lock-constant" id="BORDER_END_STYLE">BORDER_END_STYLE</span> = <span class="jde-java-font-lock-number">61</span>,
                                 <span class="jde-java-font-lock-constant" id="BORDER_END_WIDTH">BORDER_END_WIDTH</span> = <span class="jde-java-font-lock-number">62</span>,
                          <span class="jde-java-font-lock-constant" id="BORDER_END_WIDTH_LENGTH">BORDER_END_WIDTH_LENGTH</span> = <span class="jde-java-font-lock-number">63</span>,
                  <span class="jde-java-font-lock-constant" id="BORDER_END_WIDTH_CONDITIONALITY">BORDER_END_WIDTH_CONDITIONALITY</span> = <span class="jde-java-font-lock-number">64</span>,
                               <span class="jde-java-font-lock-constant" id="BORDER_START_COLOR">BORDER_START_COLOR</span> = <span class="jde-java-font-lock-number">65</span>,
                          <span class="jde-java-font-lock-constant" id="BORDER_START_PRECEDENCE">BORDER_START_PRECEDENCE</span> = <span class="jde-java-font-lock-number">66</span>,
                               <span class="jde-java-font-lock-constant" id="BORDER_START_STYLE">BORDER_START_STYLE</span> = <span class="jde-java-font-lock-number">67</span>,
                               <span class="jde-java-font-lock-constant" id="BORDER_START_WIDTH">BORDER_START_WIDTH</span> = <span class="jde-java-font-lock-number">68</span>,
                        <span class="jde-java-font-lock-constant" id="BORDER_START_WIDTH_LENGTH">BORDER_START_WIDTH_LENGTH</span> = <span class="jde-java-font-lock-number">69</span>,
                <span class="jde-java-font-lock-constant" id="BORDER_START_WIDTH_CONDITIONALITY">BORDER_START_WIDTH_CONDITIONALITY</span> = <span class="jde-java-font-lock-number">70</span>,
  
                              <span class="jde-java-font-lock-constant" id="BORDER_BOTTOM_COLOR">BORDER_BOTTOM_COLOR</span> = <span class="jde-java-font-lock-number">71</span>,
                              <span class="jde-java-font-lock-constant" id="BORDER_BOTTOM_STYLE">BORDER_BOTTOM_STYLE</span> = <span class="jde-java-font-lock-number">72</span>,
                              <span class="jde-java-font-lock-constant" id="BORDER_BOTTOM_WIDTH">BORDER_BOTTOM_WIDTH</span> = <span class="jde-java-font-lock-number">73</span>,
                                <span class="jde-java-font-lock-constant" id="BORDER_LEFT_COLOR">BORDER_LEFT_COLOR</span> = <span class="jde-java-font-lock-number">74</span>,
                                <span class="jde-java-font-lock-constant" id="BORDER_LEFT_STYLE">BORDER_LEFT_STYLE</span> = <span class="jde-java-font-lock-number">75</span>,
                                <span class="jde-java-font-lock-constant" id="BORDER_LEFT_WIDTH">BORDER_LEFT_WIDTH</span> = <span class="jde-java-font-lock-number">76</span>,
                               <span class="jde-java-font-lock-constant" id="BORDER_RIGHT_COLOR">BORDER_RIGHT_COLOR</span> = <span class="jde-java-font-lock-number">77</span>,
                               <span class="jde-java-font-lock-constant" id="BORDER_RIGHT_STYLE">BORDER_RIGHT_STYLE</span> = <span class="jde-java-font-lock-number">78</span>,
                               <span class="jde-java-font-lock-constant" id="BORDER_RIGHT_WIDTH">BORDER_RIGHT_WIDTH</span> = <span class="jde-java-font-lock-number">79</span>,
                                 <span class="jde-java-font-lock-constant" id="BORDER_TOP_COLOR">BORDER_TOP_COLOR</span> = <span class="jde-java-font-lock-number">80</span>,
                                 <span class="jde-java-font-lock-constant" id="BORDER_TOP_STYLE">BORDER_TOP_STYLE</span> = <span class="jde-java-font-lock-number">81</span>,
                                 <span class="jde-java-font-lock-constant" id="BORDER_TOP_WIDTH">BORDER_TOP_WIDTH</span> = <span class="jde-java-font-lock-number">82</span>,
  
                                  <span class="jde-java-font-lock-constant" id="BORDER_COLLAPSE">BORDER_COLLAPSE</span> = <span class="jde-java-font-lock-number">83</span>,
                                <span class="jde-java-font-lock-constant" id="BORDER_SEPARATION">BORDER_SEPARATION</span> = <span class="jde-java-font-lock-number">84</span>,
    <span class="jde-java-font-lock-constant" id="BORDER_SEPARATION_BLOCK_PROGRESSION_DIRECTION">BORDER_SEPARATION_BLOCK_PROGRESSION_DIRECTION</span> = <span class="jde-java-font-lock-number">85</span>,
   <span class="jde-java-font-lock-constant" id="BORDER_SEPARATION_INLINE_PROGRESSION_DIRECTION">BORDER_SEPARATION_INLINE_PROGRESSION_DIRECTION</span> = <span class="jde-java-font-lock-number">86</span>,
                                           <span class="jde-java-font-lock-constant" id="BOTTOM">BOTTOM</span> = <span class="jde-java-font-lock-number">87</span>,
                                      <span class="jde-java-font-lock-constant" id="BREAK_AFTER">BREAK_AFTER</span> = <span class="jde-java-font-lock-number">88</span>,
                                     <span class="jde-java-font-lock-constant" id="BREAK_BEFORE">BREAK_BEFORE</span> = <span class="jde-java-font-lock-number">89</span>,
                                     <span class="jde-java-font-lock-constant" id="CAPTION_SIDE">CAPTION_SIDE</span> = <span class="jde-java-font-lock-number">90</span>,
                                        <span class="jde-java-font-lock-constant" id="CASE_NAME">CASE_NAME</span> = <span class="jde-java-font-lock-number">91</span>,
                                       <span class="jde-java-font-lock-constant" id="CASE_TITLE">CASE_TITLE</span> = <span class="jde-java-font-lock-number">92</span>,
                                        <span class="jde-java-font-lock-constant" id="CHARACTER">CHARACTER</span> = <span class="jde-java-font-lock-number">93</span>,
                                            <span class="jde-java-font-lock-constant" id="CLEAR">CLEAR</span> = <span class="jde-java-font-lock-number">94</span>,
                                             <span class="jde-java-font-lock-constant" id="CLIP">CLIP</span> = <span class="jde-java-font-lock-number">95</span>,
                                            <span class="jde-java-font-lock-constant" id="COLOR">COLOR</span> = <span class="jde-java-font-lock-number">96</span>,
                               <span class="jde-java-font-lock-constant" id="COLOR_PROFILE_NAME">COLOR_PROFILE_NAME</span> = <span class="jde-java-font-lock-number">97</span>,
                                     <span class="jde-java-font-lock-constant" id="COLUMN_COUNT">COLUMN_COUNT</span> = <span class="jde-java-font-lock-number">98</span>,
                                       <span class="jde-java-font-lock-constant" id="COLUMN_GAP">COLUMN_GAP</span> = <span class="jde-java-font-lock-number">99</span>,
                                     <span class="jde-java-font-lock-constant" id="COLUMN_WIDTH">COLUMN_WIDTH</span> = <span class="jde-java-font-lock-number">100</span>,
                                   <span class="jde-java-font-lock-constant" id="CONTENT_HEIGHT">CONTENT_HEIGHT</span> = <span class="jde-java-font-lock-number">101</span>,
                                     <span class="jde-java-font-lock-constant" id="CONTENT_TYPE">CONTENT_TYPE</span> = <span class="jde-java-font-lock-number">102</span>,
                                    <span class="jde-java-font-lock-constant" id="CONTENT_WIDTH">CONTENT_WIDTH</span> = <span class="jde-java-font-lock-number">103</span>,
                                          <span class="jde-java-font-lock-constant" id="COUNTRY">COUNTRY</span> = <span class="jde-java-font-lock-number">104</span>,
                                        <span class="jde-java-font-lock-constant" id="CUE_AFTER">CUE_AFTER</span> = <span class="jde-java-font-lock-number">105</span>,
                                       <span class="jde-java-font-lock-constant" id="CUE_BEFORE">CUE_BEFORE</span> = <span class="jde-java-font-lock-number">106</span>,
                     <span class="jde-java-font-lock-constant" id="DESTINATION_PLACEMENT_OFFSET">DESTINATION_PLACEMENT_OFFSET</span> = <span class="jde-java-font-lock-number">107</span>,
                                        <span class="jde-java-font-lock-constant" id="DIRECTION">DIRECTION</span> = <span class="jde-java-font-lock-number">108</span>,
                                    <span class="jde-java-font-lock-constant" id="DISPLAY_ALIGN">DISPLAY_ALIGN</span> = <span class="jde-java-font-lock-number">109</span>,
                                <span class="jde-java-font-lock-constant" id="DOMINANT_BASELINE">DOMINANT_BASELINE</span> = <span class="jde-java-font-lock-number">110</span>,
                                        <span class="jde-java-font-lock-constant" id="ELEVATION">ELEVATION</span> = <span class="jde-java-font-lock-number">111</span>,
                                      <span class="jde-java-font-lock-constant" id="EMPTY_CELLS">EMPTY_CELLS</span> = <span class="jde-java-font-lock-number">112</span>,
                                       <span class="jde-java-font-lock-constant" id="END_INDENT">END_INDENT</span> = <span class="jde-java-font-lock-number">113</span>,
                                         <span class="jde-java-font-lock-constant" id="ENDS_ROW">ENDS_ROW</span> = <span class="jde-java-font-lock-number">114</span>,
                                           <span class="jde-java-font-lock-constant" id="EXTENT">EXTENT</span> = <span class="jde-java-font-lock-number">115</span>,
                             <span class="jde-java-font-lock-constant" id="EXTERNAL_DESTINATION">EXTERNAL_DESTINATION</span> = <span class="jde-java-font-lock-number">116</span>,
                                            <span class="jde-java-font-lock-constant" id="FLOAT">FLOAT</span> = <span class="jde-java-font-lock-number">117</span>,
                                        <span class="jde-java-font-lock-constant" id="FLOW_NAME">FLOW_NAME</span> = <span class="jde-java-font-lock-number">118</span>,
                                      <span class="jde-java-font-lock-constant" id="FONT_FAMILY">FONT_FAMILY</span> = <span class="jde-java-font-lock-number">119</span>,
                          <span class="jde-java-font-lock-constant" id="FONT_SELECTION_STRATEGY">FONT_SELECTION_STRATEGY</span> = <span class="jde-java-font-lock-number">120</span>,
                                 <span class="jde-java-font-lock-constant" id="FONT_SIZE_ADJUST">FONT_SIZE_ADJUST</span> = <span class="jde-java-font-lock-number">121</span>,
                                     <span class="jde-java-font-lock-constant" id="FONT_STRETCH">FONT_STRETCH</span> = <span class="jde-java-font-lock-number">122</span>,
                                       <span class="jde-java-font-lock-constant" id="FONT_STYLE">FONT_STYLE</span> = <span class="jde-java-font-lock-number">123</span>,
                                     <span class="jde-java-font-lock-constant" id="FONT_VARIANT">FONT_VARIANT</span> = <span class="jde-java-font-lock-number">124</span>,
                                      <span class="jde-java-font-lock-constant" id="FONT_WEIGHT">FONT_WEIGHT</span> = <span class="jde-java-font-lock-number">125</span>,
                                 <span class="jde-java-font-lock-constant" id="FORCE_PAGE_COUNT">FORCE_PAGE_COUNT</span> = <span class="jde-java-font-lock-number">126</span>,
                                           <span class="jde-java-font-lock-constant" id="FORMAT">FORMAT</span> = <span class="jde-java-font-lock-number">127</span>,
                     <span class="jde-java-font-lock-constant" id="GLYPH_ORIENTATION_HORIZONTAL">GLYPH_ORIENTATION_HORIZONTAL</span> = <span class="jde-java-font-lock-number">128</span>,
                       <span class="jde-java-font-lock-constant" id="GLYPH_ORIENTATION_VERTICAL">GLYPH_ORIENTATION_VERTICAL</span> = <span class="jde-java-font-lock-number">129</span>,
                               <span class="jde-java-font-lock-constant" id="GROUPING_SEPARATOR">GROUPING_SEPARATOR</span> = <span class="jde-java-font-lock-number">130</span>,
                                    <span class="jde-java-font-lock-constant" id="GROUPING_SIZE">GROUPING_SIZE</span> = <span class="jde-java-font-lock-number">131</span>,
                                           <span class="jde-java-font-lock-constant" id="HEIGHT">HEIGHT</span> = <span class="jde-java-font-lock-number">132</span>,
                                        <span class="jde-java-font-lock-constant" id="HYPHENATE">HYPHENATE</span> = <span class="jde-java-font-lock-number">133</span>,
                            <span class="jde-java-font-lock-constant" id="HYPHENATION_CHARACTER">HYPHENATION_CHARACTER</span> = <span class="jde-java-font-lock-number">134</span>,
                                 <span class="jde-java-font-lock-constant" id="HYPHENATION_KEEP">HYPHENATION_KEEP</span> = <span class="jde-java-font-lock-number">135</span>,
                         <span class="jde-java-font-lock-constant" id="HYPHENATION_LADDER_COUNT">HYPHENATION_LADDER_COUNT</span> = <span class="jde-java-font-lock-number">136</span>,
                 <span class="jde-java-font-lock-constant" id="HYPHENATION_PUSH_CHARACTER_COUNT">HYPHENATION_PUSH_CHARACTER_COUNT</span> = <span class="jde-java-font-lock-number">137</span>,
               <span class="jde-java-font-lock-constant" id="HYPHENATION_REMAIN_CHARACTER_COUNT">HYPHENATION_REMAIN_CHARACTER_COUNT</span> = <span class="jde-java-font-lock-number">138</span>,
                                               <span class="jde-java-font-lock-constant" id="ID">ID</span> = <span class="jde-java-font-lock-number">139</span>,
                             <span class="jde-java-font-lock-constant" id="INDICATE_DESTINATION">INDICATE_DESTINATION</span> = <span class="jde-java-font-lock-number">140</span>,
                              <span class="jde-java-font-lock-constant" id="INITIAL_PAGE_NUMBER">INITIAL_PAGE_NUMBER</span> = <span class="jde-java-font-lock-number">141</span>,
                     <span class="jde-java-font-lock-constant" id="INLINE_PROGRESSION_DIMENSION">INLINE_PROGRESSION_DIMENSION</span> = <span class="jde-java-font-lock-number">142</span>,
             <span class="jde-java-font-lock-constant" id="INLINE_PROGRESSION_DIMENSION_MINIMUM">INLINE_PROGRESSION_DIMENSION_MINIMUM</span> = <span class="jde-java-font-lock-number">143</span>,
             <span class="jde-java-font-lock-constant" id="INLINE_PROGRESSION_DIMENSION_OPTIMUM">INLINE_PROGRESSION_DIMENSION_OPTIMUM</span> = <span class="jde-java-font-lock-number">144</span>,
             <span class="jde-java-font-lock-constant" id="INLINE_PROGRESSION_DIMENSION_MAXIMUM">INLINE_PROGRESSION_DIMENSION_MAXIMUM</span> = <span class="jde-java-font-lock-number">145</span>,
                             <span class="jde-java-font-lock-constant" id="INTERNAL_DESTINATION">INTERNAL_DESTINATION</span> = <span class="jde-java-font-lock-number">146</span>,
                               <span class="jde-java-font-lock-constant" id="INTRUSION_DISPLACE">INTRUSION_DISPLACE</span> = <span class="jde-java-font-lock-number">147</span>,
                                    <span class="jde-java-font-lock-constant" id="KEEP_TOGETHER">KEEP_TOGETHER</span> = <span class="jde-java-font-lock-number">148</span>,
                        <span class="jde-java-font-lock-constant" id="KEEP_TOGETHER_WITHIN_LINE">KEEP_TOGETHER_WITHIN_LINE</span> = <span class="jde-java-font-lock-number">149</span>,
                        <span class="jde-java-font-lock-constant" id="KEEP_TOGETHER_WITHIN_PAGE">KEEP_TOGETHER_WITHIN_PAGE</span> = <span class="jde-java-font-lock-number">150</span>,
                      <span class="jde-java-font-lock-constant" id="KEEP_TOGETHER_WITHIN_COLUMN">KEEP_TOGETHER_WITHIN_COLUMN</span> = <span class="jde-java-font-lock-number">151</span>,
                                   <span class="jde-java-font-lock-constant" id="KEEP_WITH_NEXT">KEEP_WITH_NEXT</span> = <span class="jde-java-font-lock-number">152</span>,
                       <span class="jde-java-font-lock-constant" id="KEEP_WITH_NEXT_WITHIN_LINE">KEEP_WITH_NEXT_WITHIN_LINE</span> = <span class="jde-java-font-lock-number">153</span>,
                       <span class="jde-java-font-lock-constant" id="KEEP_WITH_NEXT_WITHIN_PAGE">KEEP_WITH_NEXT_WITHIN_PAGE</span> = <span class="jde-java-font-lock-number">154</span>,
                     <span class="jde-java-font-lock-constant" id="KEEP_WITH_NEXT_WITHIN_COLUMN">KEEP_WITH_NEXT_WITHIN_COLUMN</span> = <span class="jde-java-font-lock-number">155</span>,
                               <span class="jde-java-font-lock-constant" id="KEEP_WITH_PREVIOUS">KEEP_WITH_PREVIOUS</span> = <span class="jde-java-font-lock-number">156</span>,
                   <span class="jde-java-font-lock-constant" id="KEEP_WITH_PREVIOUS_WITHIN_LINE">KEEP_WITH_PREVIOUS_WITHIN_LINE</span> = <span class="jde-java-font-lock-number">157</span>,
                   <span class="jde-java-font-lock-constant" id="KEEP_WITH_PREVIOUS_WITHIN_PAGE">KEEP_WITH_PREVIOUS_WITHIN_PAGE</span> = <span class="jde-java-font-lock-number">158</span>,
                 <span class="jde-java-font-lock-constant" id="KEEP_WITH_PREVIOUS_WITHIN_COLUMN">KEEP_WITH_PREVIOUS_WITHIN_COLUMN</span> = <span class="jde-java-font-lock-number">159</span>,
                                         <span class="jde-java-font-lock-constant" id="LANGUAGE">LANGUAGE</span> = <span class="jde-java-font-lock-number">160</span>,
                             <span class="jde-java-font-lock-constant" id="LAST_LINE_END_INDENT">LAST_LINE_END_INDENT</span> = <span class="jde-java-font-lock-number">161</span>,
                                 <span class="jde-java-font-lock-constant" id="LEADER_ALIGNMENT">LEADER_ALIGNMENT</span> = <span class="jde-java-font-lock-number">162</span>,
                                    <span class="jde-java-font-lock-constant" id="LEADER_LENGTH">LEADER_LENGTH</span> = <span class="jde-java-font-lock-number">163</span>,
                            <span class="jde-java-font-lock-constant" id="LEADER_LENGTH_MINIMUM">LEADER_LENGTH_MINIMUM</span> = <span class="jde-java-font-lock-number">164</span>,
                            <span class="jde-java-font-lock-constant" id="LEADER_LENGTH_OPTIMUM">LEADER_LENGTH_OPTIMUM</span> = <span class="jde-java-font-lock-number">165</span>,
                            <span class="jde-java-font-lock-constant" id="LEADER_LENGTH_MAXIMUM">LEADER_LENGTH_MAXIMUM</span> = <span class="jde-java-font-lock-number">166</span>,
                                   <span class="jde-java-font-lock-constant" id="LEADER_PATTERN">LEADER_PATTERN</span> = <span class="jde-java-font-lock-number">167</span>,
                             <span class="jde-java-font-lock-constant" id="LEADER_PATTERN_WIDTH">LEADER_PATTERN_WIDTH</span> = <span class="jde-java-font-lock-number">168</span>,
                                             <span class="jde-java-font-lock-constant" id="LEFT">LEFT</span> = <span class="jde-java-font-lock-number">169</span>,
                                   <span class="jde-java-font-lock-constant" id="LETTER_SPACING">LETTER_SPACING</span> = <span class="jde-java-font-lock-number">170</span>,
                           <span class="jde-java-font-lock-constant" id="LETTER_SPACING_MINIMUM">LETTER_SPACING_MINIMUM</span> = <span class="jde-java-font-lock-number">171</span>,
                           <span class="jde-java-font-lock-constant" id="LETTER_SPACING_OPTIMUM">LETTER_SPACING_OPTIMUM</span> = <span class="jde-java-font-lock-number">172</span>,
                           <span class="jde-java-font-lock-constant" id="LETTER_SPACING_MAXIMUM">LETTER_SPACING_MAXIMUM</span> = <span class="jde-java-font-lock-number">173</span>,
                    <span class="jde-java-font-lock-constant" id="LETTER_SPACING_CONDITIONALITY">LETTER_SPACING_CONDITIONALITY</span> = <span class="jde-java-font-lock-number">174</span>,
                        <span class="jde-java-font-lock-constant" id="LETTER_SPACING_PRECEDENCE">LETTER_SPACING_PRECEDENCE</span> = <span class="jde-java-font-lock-number">175</span>,
                                     <span class="jde-java-font-lock-constant" id="LETTER_VALUE">LETTER_VALUE</span> = <span class="jde-java-font-lock-number">176</span>,
                               <span class="jde-java-font-lock-constant" id="LINEFEED_TREATMENT">LINEFEED_TREATMENT</span> = <span class="jde-java-font-lock-number">177</span>,
                                      <span class="jde-java-font-lock-constant" id="LINE_HEIGHT">LINE_HEIGHT</span> = <span class="jde-java-font-lock-number">178</span>,
                              <span class="jde-java-font-lock-constant" id="LINE_HEIGHT_MINIMUM">LINE_HEIGHT_MINIMUM</span> = <span class="jde-java-font-lock-number">179</span>,
                              <span class="jde-java-font-lock-constant" id="LINE_HEIGHT_OPTIMUM">LINE_HEIGHT_OPTIMUM</span> = <span class="jde-java-font-lock-number">180</span>,
                              <span class="jde-java-font-lock-constant" id="LINE_HEIGHT_MAXIMUM">LINE_HEIGHT_MAXIMUM</span> = <span class="jde-java-font-lock-number">181</span>,
                       <span class="jde-java-font-lock-constant" id="LINE_HEIGHT_CONDITIONALITY">LINE_HEIGHT_CONDITIONALITY</span> = <span class="jde-java-font-lock-number">182</span>,
                           <span class="jde-java-font-lock-constant" id="LINE_HEIGHT_PRECEDENCE">LINE_HEIGHT_PRECEDENCE</span> = <span class="jde-java-font-lock-number">183</span>,
                     <span class="jde-java-font-lock-constant" id="LINE_HEIGHT_SHIFT_ADJUSTMENT">LINE_HEIGHT_SHIFT_ADJUSTMENT</span> = <span class="jde-java-font-lock-number">184</span>,
                           <span class="jde-java-font-lock-constant" id="LINE_STACKING_STRATEGY">LINE_STACKING_STRATEGY</span> = <span class="jde-java-font-lock-number">185</span>,
  
                                <span class="jde-java-font-lock-constant" id="MARKER_CLASS_NAME">MARKER_CLASS_NAME</span> = <span class="jde-java-font-lock-number">186</span>,
                                      <span class="jde-java-font-lock-constant" id="MASTER_NAME">MASTER_NAME</span> = <span class="jde-java-font-lock-number">187</span>,
                                 <span class="jde-java-font-lock-constant" id="MASTER_REFERENCE">MASTER_REFERENCE</span> = <span class="jde-java-font-lock-number">188</span>,
                                       <span class="jde-java-font-lock-constant" id="MAX_HEIGHT">MAX_HEIGHT</span> = <span class="jde-java-font-lock-number">189</span>,
                                  <span class="jde-java-font-lock-constant" id="MAXIMUM_REPEATS">MAXIMUM_REPEATS</span> = <span class="jde-java-font-lock-number">190</span>,
                                        <span class="jde-java-font-lock-constant" id="MAX_WIDTH">MAX_WIDTH</span> = <span class="jde-java-font-lock-number">191</span>,
                                      <span class="jde-java-font-lock-constant" id="MEDIA_USAGE">MEDIA_USAGE</span> = <span class="jde-java-font-lock-number">192</span>,
                                       <span class="jde-java-font-lock-constant" id="MIN_HEIGHT">MIN_HEIGHT</span> = <span class="jde-java-font-lock-number">193</span>,
                                        <span class="jde-java-font-lock-constant" id="MIN_WIDTH">MIN_WIDTH</span> = <span class="jde-java-font-lock-number">194</span>,
                          <span class="jde-java-font-lock-constant" id="NUMBER_COLUMNS_REPEATED">NUMBER_COLUMNS_REPEATED</span> = <span class="jde-java-font-lock-number">195</span>,
                              <span class="jde-java-font-lock-constant" id="NUMBER_ROWS_SPANNED">NUMBER_ROWS_SPANNED</span> = <span class="jde-java-font-lock-number">196</span>,
                                      <span class="jde-java-font-lock-constant" id="ODD_OR_EVEN">ODD_OR_EVEN</span> = <span class="jde-java-font-lock-number">197</span>,
                                          <span class="jde-java-font-lock-constant" id="ORPHANS">ORPHANS</span> = <span class="jde-java-font-lock-number">198</span>,
                                         <span class="jde-java-font-lock-constant" id="OVERFLOW">OVERFLOW</span> = <span class="jde-java-font-lock-number">199</span>,
  
          <span class="comment">// Padding corresponding properties
  </span>                                  <span class="jde-java-font-lock-constant" id="PADDING_AFTER">PADDING_AFTER</span> = <span class="jde-java-font-lock-number">200</span>,
                             <span class="jde-java-font-lock-constant" id="PADDING_AFTER_LENGTH">PADDING_AFTER_LENGTH</span> = <span class="jde-java-font-lock-number">201</span>,
                     <span class="jde-java-font-lock-constant" id="PADDING_AFTER_CONDITIONALITY">PADDING_AFTER_CONDITIONALITY</span> = <span class="jde-java-font-lock-number">202</span>,
                                   <span class="jde-java-font-lock-constant" id="PADDING_BEFORE">PADDING_BEFORE</span> = <span class="jde-java-font-lock-number">203</span>,
                            <span class="jde-java-font-lock-constant" id="PADDING_BEFORE_LENGTH">PADDING_BEFORE_LENGTH</span> = <span class="jde-java-font-lock-number">204</span>,
                    <span class="jde-java-font-lock-constant" id="PADDING_BEFORE_CONDITIONALITY">PADDING_BEFORE_CONDITIONALITY</span> = <span class="jde-java-font-lock-number">205</span>,
                                      <span class="jde-java-font-lock-constant" id="PADDING_END">PADDING_END</span> = <span class="jde-java-font-lock-number">206</span>,
                               <span class="jde-java-font-lock-constant" id="PADDING_END_LENGTH">PADDING_END_LENGTH</span> = <span class="jde-java-font-lock-number">207</span>,
                       <span class="jde-java-font-lock-constant" id="PADDING_END_CONDITIONALITY">PADDING_END_CONDITIONALITY</span> = <span class="jde-java-font-lock-number">208</span>,
                                    <span class="jde-java-font-lock-constant" id="PADDING_START">PADDING_START</span> = <span class="jde-java-font-lock-number">209</span>,
                             <span class="jde-java-font-lock-constant" id="PADDING_START_LENGTH">PADDING_START_LENGTH</span> = <span class="jde-java-font-lock-number">210</span>,
                     <span class="jde-java-font-lock-constant" id="PADDING_START_CONDITIONALITY">PADDING_START_CONDITIONALITY</span> = <span class="jde-java-font-lock-number">211</span>,
  
                                   <span class="jde-java-font-lock-constant" id="PADDING_BOTTOM">PADDING_BOTTOM</span> = <span class="jde-java-font-lock-number">212</span>,
                                     <span class="jde-java-font-lock-constant" id="PADDING_LEFT">PADDING_LEFT</span> = <span class="jde-java-font-lock-number">213</span>,
                                    <span class="jde-java-font-lock-constant" id="PADDING_RIGHT">PADDING_RIGHT</span> = <span class="jde-java-font-lock-number">214</span>,
                                      <span class="jde-java-font-lock-constant" id="PADDING_TOP">PADDING_TOP</span> = <span class="jde-java-font-lock-number">215</span>,
  
                                      <span class="jde-java-font-lock-constant" id="PAGE_HEIGHT">PAGE_HEIGHT</span> = <span class="jde-java-font-lock-number">216</span>,
                                    <span class="jde-java-font-lock-constant" id="PAGE_POSITION">PAGE_POSITION</span> = <span class="jde-java-font-lock-number">217</span>,
                                       <span class="jde-java-font-lock-constant" id="PAGE_WIDTH">PAGE_WIDTH</span> = <span class="jde-java-font-lock-number">218</span>,
                                      <span class="jde-java-font-lock-constant" id="PAUSE_AFTER">PAUSE_AFTER</span> = <span class="jde-java-font-lock-number">219</span>,
                                     <span class="jde-java-font-lock-constant" id="PAUSE_BEFORE">PAUSE_BEFORE</span> = <span class="jde-java-font-lock-number">220</span>,
                                            <span class="jde-java-font-lock-constant" id="PITCH">PITCH</span> = <span class="jde-java-font-lock-number">221</span>,
                                      <span class="jde-java-font-lock-constant" id="PITCH_RANGE">PITCH_RANGE</span> = <span class="jde-java-font-lock-number">222</span>,
                                      <span class="jde-java-font-lock-constant" id="PLAY_DURING">PLAY_DURING</span> = <span class="jde-java-font-lock-number">223</span>,
                                       <span class="jde-java-font-lock-constant" id="PRECEDENCE">PRECEDENCE</span> = <span class="jde-java-font-lock-number">224</span>,
              <span class="jde-java-font-lock-constant" id="PROVISIONAL_DISTANCE_BETWEEN_STARTS">PROVISIONAL_DISTANCE_BETWEEN_STARTS</span> = <span class="jde-java-font-lock-number">225</span>,
                     <span class="jde-java-font-lock-constant" id="PROVISIONAL_LABEL_SEPARATION">PROVISIONAL_LABEL_SEPARATION</span> = <span class="jde-java-font-lock-number">226</span>,
                            <span class="jde-java-font-lock-constant" id="REFERENCE_ORIENTATION">REFERENCE_ORIENTATION</span> = <span class="jde-java-font-lock-number">227</span>,
                                           <span class="jde-java-font-lock-constant" id="REF_ID">REF_ID</span> = <span class="jde-java-font-lock-number">228</span>,
                                      <span class="jde-java-font-lock-constant" id="REGION_NAME">REGION_NAME</span> = <span class="jde-java-font-lock-number">229</span>,
                                   <span class="jde-java-font-lock-constant" id="RELATIVE_ALIGN">RELATIVE_ALIGN</span> = <span class="jde-java-font-lock-number">230</span>,
                                <span class="jde-java-font-lock-constant" id="RELATIVE_POSITION">RELATIVE_POSITION</span> = <span class="jde-java-font-lock-number">231</span>,
                                 <span class="jde-java-font-lock-constant" id="RENDERING_INTENT">RENDERING_INTENT</span> = <span class="jde-java-font-lock-number">232</span>,
                                <span class="jde-java-font-lock-constant" id="RETRIEVE_BOUNDARY">RETRIEVE_BOUNDARY</span> = <span class="jde-java-font-lock-number">233</span>,
                              <span class="jde-java-font-lock-constant" id="RETRIEVE_CLASS_NAME">RETRIEVE_CLASS_NAME</span> = <span class="jde-java-font-lock-number">234</span>,
                                <span class="jde-java-font-lock-constant" id="RETRIEVE_POSITION">RETRIEVE_POSITION</span> = <span class="jde-java-font-lock-number">235</span>,
                                         <span class="jde-java-font-lock-constant" id="RICHNESS">RICHNESS</span> = <span class="jde-java-font-lock-number">236</span>,
                                            <span class="jde-java-font-lock-constant" id="RIGHT">RIGHT</span> = <span class="jde-java-font-lock-number">237</span>,
                                             <span class="jde-java-font-lock-constant" id="ROLE">ROLE</span> = <span class="jde-java-font-lock-number">238</span>,
                                       <span class="jde-java-font-lock-constant" id="RULE_STYLE">RULE_STYLE</span> = <span class="jde-java-font-lock-number">239</span>,
                                   <span class="jde-java-font-lock-constant" id="RULE_THICKNESS">RULE_THICKNESS</span> = <span class="jde-java-font-lock-number">240</span>,
                                          <span class="jde-java-font-lock-constant" id="SCALING">SCALING</span> = <span class="jde-java-font-lock-number">241</span>,
                                   <span class="jde-java-font-lock-constant" id="SCALING_METHOD">SCALING_METHOD</span> = <span class="jde-java-font-lock-number">242</span>,
                                     <span class="jde-java-font-lock-constant" id="SCORE_SPACES">SCORE_SPACES</span> = <span class="jde-java-font-lock-number">243</span>,
                                           <span class="jde-java-font-lock-constant" id="SCRIPT">SCRIPT</span> = <span class="jde-java-font-lock-number">244</span>,
                                 <span class="jde-java-font-lock-constant" id="SHOW_DESTINATION">SHOW_DESTINATION</span> = <span class="jde-java-font-lock-number">245</span>,
                                  <span class="jde-java-font-lock-constant" id="SOURCE_DOCUMENT">SOURCE_DOCUMENT</span> = <span class="jde-java-font-lock-number">246</span>,
  
          <span class="comment">// Space/margin corresponding properties
  </span>                                    <span class="jde-java-font-lock-constant" id="SPACE_AFTER">SPACE_AFTER</span> = <span class="jde-java-font-lock-number">247</span>,
                              <span class="jde-java-font-lock-constant" id="SPACE_AFTER_MINIMUM">SPACE_AFTER_MINIMUM</span> = <span class="jde-java-font-lock-number">248</span>,
                              <span class="jde-java-font-lock-constant" id="SPACE_AFTER_OPTIMUM">SPACE_AFTER_OPTIMUM</span> = <span class="jde-java-font-lock-number">249</span>,
                              <span class="jde-java-font-lock-constant" id="SPACE_AFTER_MAXIMUM">SPACE_AFTER_MAXIMUM</span> = <span class="jde-java-font-lock-number">250</span>,
                       <span class="jde-java-font-lock-constant" id="SPACE_AFTER_CONDITIONALITY">SPACE_AFTER_CONDITIONALITY</span> = <span class="jde-java-font-lock-number">251</span>,
                           <span class="jde-java-font-lock-constant" id="SPACE_AFTER_PRECEDENCE">SPACE_AFTER_PRECEDENCE</span> = <span class="jde-java-font-lock-number">252</span>,
                                     <span class="jde-java-font-lock-constant" id="SPACE_BEFORE">SPACE_BEFORE</span> = <span class="jde-java-font-lock-number">253</span>,
                             <span class="jde-java-font-lock-constant" id="SPACE_BEFORE_MINIMUM">SPACE_BEFORE_MINIMUM</span> = <span class="jde-java-font-lock-number">254</span>,
                             <span class="jde-java-font-lock-constant" id="SPACE_BEFORE_OPTIMUM">SPACE_BEFORE_OPTIMUM</span> = <span class="jde-java-font-lock-number">255</span>,
                             <span class="jde-java-font-lock-constant" id="SPACE_BEFORE_MAXIMUM">SPACE_BEFORE_MAXIMUM</span> = <span class="jde-java-font-lock-number">256</span>,
                      <span class="jde-java-font-lock-constant" id="SPACE_BEFORE_CONDITIONALITY">SPACE_BEFORE_CONDITIONALITY</span> = <span class="jde-java-font-lock-number">257</span>,
                          <span class="jde-java-font-lock-constant" id="SPACE_BEFORE_PRECEDENCE">SPACE_BEFORE_PRECEDENCE</span> = <span class="jde-java-font-lock-number">258</span>,
                                        <span class="jde-java-font-lock-constant" id="SPACE_END">SPACE_END</span> = <span class="jde-java-font-lock-number">259</span>,
                                <span class="jde-java-font-lock-constant" id="SPACE_END_MINIMUM">SPACE_END_MINIMUM</span> = <span class="jde-java-font-lock-number">260</span>,
                                <span class="jde-java-font-lock-constant" id="SPACE_END_OPTIMUM">SPACE_END_OPTIMUM</span> = <span class="jde-java-font-lock-number">261</span>,
                                <span class="jde-java-font-lock-constant" id="SPACE_END_MAXIMUM">SPACE_END_MAXIMUM</span> = <span class="jde-java-font-lock-number">262</span>,
                         <span class="jde-java-font-lock-constant" id="SPACE_END_CONDITIONALITY">SPACE_END_CONDITIONALITY</span> = <span class="jde-java-font-lock-number">263</span>,
                             <span class="jde-java-font-lock-constant" id="SPACE_END_PRECEDENCE">SPACE_END_PRECEDENCE</span> = <span class="jde-java-font-lock-number">264</span>,
                                      <span class="jde-java-font-lock-constant" id="SPACE_START">SPACE_START</span> = <span class="jde-java-font-lock-number">265</span>,
                              <span class="jde-java-font-lock-constant" id="SPACE_START_MINIMUM">SPACE_START_MINIMUM</span> = <span class="jde-java-font-lock-number">266</span>,
                              <span class="jde-java-font-lock-constant" id="SPACE_START_OPTIMUM">SPACE_START_OPTIMUM</span> = <span class="jde-java-font-lock-number">267</span>,
                              <span class="jde-java-font-lock-constant" id="SPACE_START_MAXIMUM">SPACE_START_MAXIMUM</span> = <span class="jde-java-font-lock-number">268</span>,
                       <span class="jde-java-font-lock-constant" id="SPACE_START_CONDITIONALITY">SPACE_START_CONDITIONALITY</span> = <span class="jde-java-font-lock-number">269</span>,
                           <span class="jde-java-font-lock-constant" id="SPACE_START_PRECEDENCE">SPACE_START_PRECEDENCE</span> = <span class="jde-java-font-lock-number">270</span>,
  
                                    <span class="jde-java-font-lock-constant" id="MARGIN_BOTTOM">MARGIN_BOTTOM</span> = <span class="jde-java-font-lock-number">271</span>,
                                      <span class="jde-java-font-lock-constant" id="MARGIN_LEFT">MARGIN_LEFT</span> = <span class="jde-java-font-lock-number">272</span>,
                                     <span class="jde-java-font-lock-constant" id="MARGIN_RIGHT">MARGIN_RIGHT</span> = <span class="jde-java-font-lock-number">273</span>,
                                       <span class="jde-java-font-lock-constant" id="MARGIN_TOP">MARGIN_TOP</span> = <span class="jde-java-font-lock-number">274</span>,
  
                                             <span class="jde-java-font-lock-constant" id="SPAN">SPAN</span> = <span class="jde-java-font-lock-number">275</span>,
                                            <span class="jde-java-font-lock-constant" id="SPEAK">SPEAK</span> = <span class="jde-java-font-lock-number">276</span>,
                                     <span class="jde-java-font-lock-constant" id="SPEAK_HEADER">SPEAK_HEADER</span> = <span class="jde-java-font-lock-number">277</span>,
                                    <span class="jde-java-font-lock-constant" id="SPEAK_NUMERAL">SPEAK_NUMERAL</span> = <span class="jde-java-font-lock-number">278</span>,
                                <span class="jde-java-font-lock-constant" id="SPEAK_PUNCTUATION">SPEAK_PUNCTUATION</span> = <span class="jde-java-font-lock-number">279</span>,
                                      <span class="jde-java-font-lock-constant" id="SPEECH_RATE">SPEECH_RATE</span> = <span class="jde-java-font-lock-number">280</span>,
                                              <span class="jde-java-font-lock-constant" id="SRC">SRC</span> = <span class="jde-java-font-lock-number">281</span>,
                                     <span class="jde-java-font-lock-constant" id="START_INDENT">START_INDENT</span> = <span class="jde-java-font-lock-number">282</span>,
                                   <span class="jde-java-font-lock-constant" id="STARTING_STATE">STARTING_STATE</span> = <span class="jde-java-font-lock-number">283</span>,
                                       <span class="jde-java-font-lock-constant" id="STARTS_ROW">STARTS_ROW</span> = <span class="jde-java-font-lock-number">284</span>,
                                           <span class="jde-java-font-lock-constant" id="STRESS">STRESS</span> = <span class="jde-java-font-lock-number">285</span>,
                           <span class="jde-java-font-lock-constant" id="SUPPRESS_AT_LINE_BREAK">SUPPRESS_AT_LINE_BREAK</span> = <span class="jde-java-font-lock-number">286</span>,
                                        <span class="jde-java-font-lock-constant" id="SWITCH_TO">SWITCH_TO</span> = <span class="jde-java-font-lock-number">287</span>,
                                     <span class="jde-java-font-lock-constant" id="TABLE_LAYOUT">TABLE_LAYOUT</span> = <span class="jde-java-font-lock-number">288</span>,
                       <span class="jde-java-font-lock-constant" id="TABLE_OMIT_FOOTER_AT_BREAK">TABLE_OMIT_FOOTER_AT_BREAK</span> = <span class="jde-java-font-lock-number">289</span>,
                       <span class="jde-java-font-lock-constant" id="TABLE_OMIT_HEADER_AT_BREAK">TABLE_OMIT_HEADER_AT_BREAK</span> = <span class="jde-java-font-lock-number">290</span>,
                      <span class="jde-java-font-lock-constant" id="TARGET_PRESENTATION_CONTEXT">TARGET_PRESENTATION_CONTEXT</span> = <span class="jde-java-font-lock-number">291</span>,
                        <span class="jde-java-font-lock-constant" id="TARGET_PROCESSING_CONTEXT">TARGET_PROCESSING_CONTEXT</span> = <span class="jde-java-font-lock-number">292</span>,
                                <span class="jde-java-font-lock-constant" id="TARGET_STYLESHEET">TARGET_STYLESHEET</span> = <span class="jde-java-font-lock-number">293</span>,
                                       <span class="jde-java-font-lock-constant" id="TEXT_ALIGN">TEXT_ALIGN</span> = <span class="jde-java-font-lock-number">294</span>,
                                  <span class="jde-java-font-lock-constant" id="TEXT_ALIGN_LAST">TEXT_ALIGN_LAST</span> = <span class="jde-java-font-lock-number">295</span>,
                                    <span class="jde-java-font-lock-constant" id="TEXT_ALTITUDE">TEXT_ALTITUDE</span> = <span class="jde-java-font-lock-number">296</span>,
                                  <span class="jde-java-font-lock-constant" id="TEXT_DECORATION">TEXT_DECORATION</span> = <span class="jde-java-font-lock-number">297</span>,
                                       <span class="jde-java-font-lock-constant" id="TEXT_DEPTH">TEXT_DEPTH</span> = <span class="jde-java-font-lock-number">298</span>,
                                      <span class="jde-java-font-lock-constant" id="TEXT_INDENT">TEXT_INDENT</span> = <span class="jde-java-font-lock-number">299</span>,
                                      <span class="jde-java-font-lock-constant" id="TEXT_SHADOW">TEXT_SHADOW</span> = <span class="jde-java-font-lock-number">300</span>,
                                   <span class="jde-java-font-lock-constant" id="TEXT_TRANSFORM">TEXT_TRANSFORM</span> = <span class="jde-java-font-lock-number">301</span>,
                                              <span class="jde-java-font-lock-constant" id="TOP">TOP</span> = <span class="jde-java-font-lock-number">302</span>,
                              <span class="jde-java-font-lock-constant" id="TREAT_AS_WORD_SPACE">TREAT_AS_WORD_SPACE</span> = <span class="jde-java-font-lock-number">303</span>,
                                     <span class="jde-java-font-lock-constant" id="UNICODE_BIDI">UNICODE_BIDI</span> = <span class="jde-java-font-lock-number">304</span>,
          <span class="jde-java-font-lock-constant" id="USAGE_CONTEXT_OF_SUPPRESS_AT_LINE_BREAK">USAGE_CONTEXT_OF_SUPPRESS_AT_LINE_BREAK</span> = <span class="jde-java-font-lock-number">305</span>,
                                       <span class="jde-java-font-lock-constant" id="VISIBILITY">VISIBILITY</span> = <span class="jde-java-font-lock-number">306</span>,
                                     <span class="jde-java-font-lock-constant" id="VOICE_FAMILY">VOICE_FAMILY</span> = <span class="jde-java-font-lock-number">307</span>,
                                           <span class="jde-java-font-lock-constant" id="VOLUME">VOLUME</span> = <span class="jde-java-font-lock-number">308</span>,
                             <span class="jde-java-font-lock-constant" id="WHITE_SPACE_COLLAPSE">WHITE_SPACE_COLLAPSE</span> = <span class="jde-java-font-lock-number">309</span>,
                            <span class="jde-java-font-lock-constant" id="WHITE_SPACE_TREATMENT">WHITE_SPACE_TREATMENT</span> = <span class="jde-java-font-lock-number">310</span>,
                                           <span class="jde-java-font-lock-constant" id="WIDOWS">WIDOWS</span> = <span class="jde-java-font-lock-number">311</span>,
                                            <span class="jde-java-font-lock-constant" id="WIDTH">WIDTH</span> = <span class="jde-java-font-lock-number">312</span>,
                                     <span class="jde-java-font-lock-constant" id="WORD_SPACING">WORD_SPACING</span> = <span class="jde-java-font-lock-number">313</span>,
                             <span class="jde-java-font-lock-constant" id="WORD_SPACING_MINIMUM">WORD_SPACING_MINIMUM</span> = <span class="jde-java-font-lock-number">314</span>,
                             <span class="jde-java-font-lock-constant" id="WORD_SPACING_OPTIMUM">WORD_SPACING_OPTIMUM</span> = <span class="jde-java-font-lock-number">315</span>,
                             <span class="jde-java-font-lock-constant" id="WORD_SPACING_MAXIMUM">WORD_SPACING_MAXIMUM</span> = <span class="jde-java-font-lock-number">316</span>,
                      <span class="jde-java-font-lock-constant" id="WORD_SPACING_CONDITIONALITY">WORD_SPACING_CONDITIONALITY</span> = <span class="jde-java-font-lock-number">317</span>,
                          <span class="jde-java-font-lock-constant" id="WORD_SPACING_PRECEDENCE">WORD_SPACING_PRECEDENCE</span> = <span class="jde-java-font-lock-number">318</span>,
                                      <span class="jde-java-font-lock-constant" id="WRAP_OPTION">WRAP_OPTION</span> = <span class="jde-java-font-lock-number">319</span>,
                                          <span class="jde-java-font-lock-constant" id="Z_INDEX">Z_INDEX</span> = <span class="jde-java-font-lock-number">320</span>,
          
                              <span class="jde-java-font-lock-constant" id="LAST_PROPERTY_INDEX">LAST_PROPERTY_INDEX</span> = <span class="jde-java-font-lock-constant">Z_INDEX</span>;
  
  
      <span class="comment">/**
       * A String[] array containing the names of all of the FO properties.
       * The array is effectively 1-based, as the first element is null.
       * The list of int constants referring to the properties must be manually
       * kept in sync with the names in this array, as the constants can be
       * used to index into this, and the other property arrays.
       */</span>
  
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">String</span>[] <span class="variable-name" id="propertyNames">propertyNames</span> = {
                                          &quot;<span class="string">no-property</span>&quot;  <span class="comment">// 0
  </span>
                                       ,&quot;<span class="string">column-number</span>&quot;  <span class="comment">// 1
  </span>                            ,&quot;<span class="string">number-columns-spanned</span>&quot;  <span class="comment">// 2
  </span>
                                                ,&quot;<span class="string">font</span>&quot;  <span class="comment">// 3
  </span>                                         ,&quot;<span class="string">font-size</span>&quot;  <span class="comment">// 4
  </span>
                                        ,&quot;<span class="string">writing-mode</span>&quot;  <span class="comment">// 5
  </span>
                                          ,&quot;<span class="string">background</span>&quot;  <span class="comment">// 6
  </span>                               ,&quot;<span class="string">background-position</span>&quot;  <span class="comment">// 7
  </span>                                            ,&quot;<span class="string">border</span>&quot;  <span class="comment">// 8
  </span>                                      ,&quot;<span class="string">border-color</span>&quot;  <span class="comment">// 9
  </span>                                      ,&quot;<span class="string">border-style</span>&quot;  <span class="comment">// 10
  </span>                                      ,&quot;<span class="string">border-width</span>&quot;  <span class="comment">// 11
  </span>                                     ,&quot;<span class="string">border-bottom</span>&quot;  <span class="comment">// 12
  </span>                                       ,&quot;<span class="string">border-left</span>&quot;  <span class="comment">// 13
  </span>                                      ,&quot;<span class="string">border-right</span>&quot;  <span class="comment">// 14
  </span>                                        ,&quot;<span class="string">border-top</span>&quot;  <span class="comment">// 15
  </span>                                    ,&quot;<span class="string">border-spacing</span>&quot;  <span class="comment">// 16
  </span>                                               ,&quot;<span class="string">cue</span>&quot;  <span class="comment">// 17
  </span>                                            ,&quot;<span class="string">margin</span>&quot;  <span class="comment">// 18
  </span>                                           ,&quot;<span class="string">padding</span>&quot;  <span class="comment">// 19
  </span>                                  ,&quot;<span class="string">page-break-after</span>&quot;  <span class="comment">// 20
  </span>                                 ,&quot;<span class="string">page-break-before</span>&quot;  <span class="comment">// 21
  </span>                                 ,&quot;<span class="string">page-break-inside</span>&quot;  <span class="comment">// 22
  </span>                                             ,&quot;<span class="string">pause</span>&quot;  <span class="comment">// 23
  </span>                                          ,&quot;<span class="string">position</span>&quot;  <span class="comment">// 24
  </span>                                              ,&quot;<span class="string">size</span>&quot;  <span class="comment">// 25
  </span>                                    ,&quot;<span class="string">vertical-align</span>&quot;  <span class="comment">// 26
  </span>                                       ,&quot;<span class="string">white-space</span>&quot;  <span class="comment">// 27
  </span>                                          ,&quot;<span class="string">xml:lang</span>&quot;  <span class="comment">// 28
  </span>
                                   ,&quot;<span class="string">absolute-position</span>&quot;  <span class="comment">// 29
  </span>                                      ,&quot;<span class="string">active-state</span>&quot;  <span class="comment">// 30
  </span>                                  ,&quot;<span class="string">alignment-adjust</span>&quot;  <span class="comment">// 31
  </span>                                ,&quot;<span class="string">alignment-baseline</span>&quot;  <span class="comment">// 32
  </span>                                      ,&quot;<span class="string">auto-restore</span>&quot;  <span class="comment">// 33
  </span>                                           ,&quot;<span class="string">azimuth</span>&quot;  <span class="comment">// 34
  </span>                             ,&quot;<span class="string">background-attachment</span>&quot;  <span class="comment">// 35
  </span>                                  ,&quot;<span class="string">background-color</span>&quot;  <span class="comment">// 36
  </span>                                  ,&quot;<span class="string">background-image</span>&quot;  <span class="comment">// 37
  </span>                    ,&quot;<span class="string">background-position-horizontal</span>&quot;  <span class="comment">// 38
  </span>                      ,&quot;<span class="string">background-position-vertical</span>&quot;  <span class="comment">// 39
  </span>                                 ,&quot;<span class="string">background-repeat</span>&quot;  <span class="comment">// 40
  </span>                                    ,&quot;<span class="string">baseline-shift</span>&quot;  <span class="comment">// 41
  </span>                                ,&quot;<span class="string">blank-or-not-blank</span>&quot;  <span class="comment">// 42
  </span>                       ,&quot;<span class="string">block-progression-dimension</span>&quot;  <span class="comment">// 43
  </span>               ,&quot;<span class="string">block-progression-dimension.minimum</span>&quot;  <span class="comment">// 44
  </span>               ,&quot;<span class="string">block-progression-dimension.optimum</span>&quot;  <span class="comment">// 45
  </span>               ,&quot;<span class="string">block-progression-dimension.maximum</span>&quot;  <span class="comment">// 46
  </span>
                                  ,&quot;<span class="string">border-after-color</span>&quot;  <span class="comment">// 47
  </span>                           ,&quot;<span class="string">border-after-precedence</span>&quot;  <span class="comment">// 48
  </span>                                ,&quot;<span class="string">border-after-style</span>&quot;  <span class="comment">// 49
  </span>                                ,&quot;<span class="string">border-after-width</span>&quot;  <span class="comment">// 50
  </span>                         ,&quot;<span class="string">border-after-width.length</span>&quot;  <span class="comment">// 51
  </span>                 ,&quot;<span class="string">border-after-width.conditionality</span>&quot;  <span class="comment">// 52
  </span>                               ,&quot;<span class="string">border-before-color</span>&quot;  <span class="comment">// 53
  </span>                          ,&quot;<span class="string">border-before-precedence</span>&quot;  <span class="comment">// 54
  </span>                               ,&quot;<span class="string">border-before-style</span>&quot;  <span class="comment">// 55
  </span>                               ,&quot;<span class="string">border-before-width</span>&quot;  <span class="comment">// 56
  </span>                        ,&quot;<span class="string">border-before-width.length</span>&quot;  <span class="comment">// 57
  </span>                ,&quot;<span class="string">border-before-width.conditionality</span>&quot;  <span class="comment">// 58
  </span>                                  ,&quot;<span class="string">border-end-color</span>&quot;  <span class="comment">// 59
  </span>                             ,&quot;<span class="string">border-end-precedence</span>&quot;  <span class="comment">// 60
  </span>                                  ,&quot;<span class="string">border-end-style</span>&quot;  <span class="comment">// 61
  </span>                                  ,&quot;<span class="string">border-end-width</span>&quot;  <span class="comment">// 62
  </span>                           ,&quot;<span class="string">border-end-width.length</span>&quot;  <span class="comment">// 63
  </span>                   ,&quot;<span class="string">border-end-width.conditionality</span>&quot;  <span class="comment">// 64
  </span>                                ,&quot;<span class="string">border-start-color</span>&quot;  <span class="comment">// 65
  </span>                           ,&quot;<span class="string">border-start-precedence</span>&quot;  <span class="comment">// 66
  </span>                                ,&quot;<span class="string">border-start-style</span>&quot;  <span class="comment">// 67
  </span>                                ,&quot;<span class="string">border-start-width</span>&quot;  <span class="comment">// 68
  </span>                         ,&quot;<span class="string">border-start-width.length</span>&quot;  <span class="comment">// 69
  </span>                 ,&quot;<span class="string">border-start-width.conditionality</span>&quot;  <span class="comment">// 70
  </span>
                                 ,&quot;<span class="string">border-bottom-color</span>&quot;  <span class="comment">// 71
  </span>                               ,&quot;<span class="string">border-bottom-style</span>&quot;  <span class="comment">// 72
  </span>                               ,&quot;<span class="string">border-bottom-width</span>&quot;  <span class="comment">// 73
  </span>                                 ,&quot;<span class="string">border-left-color</span>&quot;  <span class="comment">// 74
  </span>                                 ,&quot;<span class="string">border-left-style</span>&quot;  <span class="comment">// 75
  </span>                                 ,&quot;<span class="string">border-left-width</span>&quot;  <span class="comment">// 76
  </span>                                ,&quot;<span class="string">border-right-color</span>&quot;  <span class="comment">// 77
  </span>                                ,&quot;<span class="string">border-right-style</span>&quot;  <span class="comment">// 78
  </span>                                ,&quot;<span class="string">border-right-width</span>&quot;  <span class="comment">// 79
  </span>                                  ,&quot;<span class="string">border-top-color</span>&quot;  <span class="comment">// 80
  </span>                                  ,&quot;<span class="string">border-top-style</span>&quot;  <span class="comment">// 81
  </span>                                  ,&quot;<span class="string">border-top-width</span>&quot;  <span class="comment">// 82
  </span>
                                     ,&quot;<span class="string">border-collapse</span>&quot;  <span class="comment">// 83
  </span>                                 ,&quot;<span class="string">border-separation</span>&quot;  <span class="comment">// 84
  </span>     ,&quot;<span class="string">border-separation.block-progression-direction</span>&quot;  <span class="comment">// 85
  </span>    ,&quot;<span class="string">border-separation.inline-progression-direction</span>&quot;  <span class="comment">// 86
  </span>                                            ,&quot;<span class="string">bottom</span>&quot;  <span class="comment">// 87
  </span>                                       ,&quot;<span class="string">break-after</span>&quot;  <span class="comment">// 88
  </span>                                      ,&quot;<span class="string">break-before</span>&quot;  <span class="comment">// 89
  </span>                                      ,&quot;<span class="string">caption-side</span>&quot;  <span class="comment">// 90
  </span>                                         ,&quot;<span class="string">case-name</span>&quot;  <span class="comment">// 91
  </span>                                        ,&quot;<span class="string">case-title</span>&quot;  <span class="comment">// 92
  </span>                                         ,&quot;<span class="string">character</span>&quot;  <span class="comment">// 93
  </span>                                             ,&quot;<span class="string">clear</span>&quot;  <span class="comment">// 94
  </span>                                              ,&quot;<span class="string">clip</span>&quot;  <span class="comment">// 95
  </span>                                             ,&quot;<span class="string">color</span>&quot;  <span class="comment">// 96
  </span>                                ,&quot;<span class="string">color-profile-name</span>&quot;  <span class="comment">// 97
  </span>                                      ,&quot;<span class="string">column-count</span>&quot;  <span class="comment">// 98
  </span>                                        ,&quot;<span class="string">column-gap</span>&quot;  <span class="comment">// 99
  </span>                                      ,&quot;<span class="string">column-width</span>&quot;  <span class="comment">// 100
  </span>                                    ,&quot;<span class="string">content-height</span>&quot;  <span class="comment">// 101
  </span>                                      ,&quot;<span class="string">content-type</span>&quot;  <span class="comment">// 102
  </span>                                     ,&quot;<span class="string">content-width</span>&quot;  <span class="comment">// 103
  </span>                                           ,&quot;<span class="string">country</span>&quot;  <span class="comment">// 104
  </span>                                         ,&quot;<span class="string">cue-after</span>&quot;  <span class="comment">// 105
  </span>                                        ,&quot;<span class="string">cue-before</span>&quot;  <span class="comment">// 106
  </span>                      ,&quot;<span class="string">destination-placement-offset</span>&quot;  <span class="comment">// 107
  </span>                                         ,&quot;<span class="string">direction</span>&quot;  <span class="comment">// 108
  </span>                                     ,&quot;<span class="string">display-align</span>&quot;  <span class="comment">// 109
  </span>                                 ,&quot;<span class="string">dominant-baseline</span>&quot;  <span class="comment">// 110
  </span>                                         ,&quot;<span class="string">elevation</span>&quot;  <span class="comment">// 111
  </span>                                       ,&quot;<span class="string">empty-cells</span>&quot;  <span class="comment">// 112
  </span>                                        ,&quot;<span class="string">end-indent</span>&quot;  <span class="comment">// 113
  </span>                                          ,&quot;<span class="string">ends-row</span>&quot;  <span class="comment">// 114
  </span>                                            ,&quot;<span class="string">extent</span>&quot;  <span class="comment">// 115
  </span>                              ,&quot;<span class="string">external-destination</span>&quot;  <span class="comment">// 116
  </span>                                             ,&quot;<span class="string">float</span>&quot;  <span class="comment">// 117
  </span>                                         ,&quot;<span class="string">flow-name</span>&quot;  <span class="comment">// 118
  </span>                                       ,&quot;<span class="string">font-family</span>&quot;  <span class="comment">// 119
  </span>                           ,&quot;<span class="string">font-selection-strategy</span>&quot;  <span class="comment">// 120
  </span>                                  ,&quot;<span class="string">font-size-adjust</span>&quot;  <span class="comment">// 121
  </span>                                      ,&quot;<span class="string">font-stretch</span>&quot;  <span class="comment">// 122
  </span>                                        ,&quot;<span class="string">font-style</span>&quot;  <span class="comment">// 123
  </span>                                      ,&quot;<span class="string">font-variant</span>&quot;  <span class="comment">// 124
  </span>                                       ,&quot;<span class="string">font-weight</span>&quot;  <span class="comment">// 125
  </span>                                  ,&quot;<span class="string">force-page-count</span>&quot;  <span class="comment">// 126
  </span>                                            ,&quot;<span class="string">format</span>&quot;  <span class="comment">// 127
  </span>                      ,&quot;<span class="string">glyph-orientation-horizontal</span>&quot;  <span class="comment">// 128
  </span>                        ,&quot;<span class="string">glyph-orientation-vertical</span>&quot;  <span class="comment">// 129
  </span>                                ,&quot;<span class="string">grouping-separator</span>&quot;  <span class="comment">// 130
  </span>                                     ,&quot;<span class="string">grouping-size</span>&quot;  <span class="comment">// 131
  </span>                                            ,&quot;<span class="string">height</span>&quot;  <span class="comment">// 132
  </span>                                         ,&quot;<span class="string">hyphenate</span>&quot;  <span class="comment">// 133
  </span>                             ,&quot;<span class="string">hyphenation-character</span>&quot;  <span class="comment">// 134
  </span>                                  ,&quot;<span class="string">hyphenation-keep</span>&quot;  <span class="comment">// 135
  </span>                          ,&quot;<span class="string">hyphenation-ladder-count</span>&quot;  <span class="comment">// 136
  </span>                  ,&quot;<span class="string">hyphenation-push-character-count</span>&quot;  <span class="comment">// 137
  </span>                ,&quot;<span class="string">hyphenation-remain-character-count</span>&quot;  <span class="comment">// 138
  </span>                                                ,&quot;<span class="string">id</span>&quot;  <span class="comment">// 139
  </span>                              ,&quot;<span class="string">indicate-destination</span>&quot;  <span class="comment">// 140
  </span>                               ,&quot;<span class="string">initial-page-number</span>&quot;  <span class="comment">// 141
  </span>                      ,&quot;<span class="string">inline-progression-dimension</span>&quot;  <span class="comment">// 142
  </span>              ,&quot;<span class="string">inline-progression-dimension.minimum</span>&quot;  <span class="comment">// 143
  </span>              ,&quot;<span class="string">inline-progression-dimension.optimum</span>&quot;  <span class="comment">// 144
  </span>              ,&quot;<span class="string">inline-progression-dimension.maximum</span>&quot;  <span class="comment">// 145
  </span>                              ,&quot;<span class="string">internal-destination</span>&quot;  <span class="comment">// 146
  </span>                                ,&quot;<span class="string">intrusion-displace</span>&quot;  <span class="comment">// 147
  </span>                                     ,&quot;<span class="string">keep-together</span>&quot;  <span class="comment">// 148
  </span>                         ,&quot;<span class="string">keep-together.within-line</span>&quot;  <span class="comment">// 149
  </span>                       ,&quot;<span class="string">keep-together.within-column</span>&quot;  <span class="comment">// 150
  </span>                         ,&quot;<span class="string">keep-together.within-page</span>&quot;  <span class="comment">// 151
  </span>                                    ,&quot;<span class="string">keep-with-next</span>&quot;  <span class="comment">// 152
  </span>                        ,&quot;<span class="string">keep-with-next.within-line</span>&quot;  <span class="comment">// 153
  </span>                      ,&quot;<span class="string">keep-with-next.within-column</span>&quot;  <span class="comment">// 154
  </span>                        ,&quot;<span class="string">keep-with-next.within-page</span>&quot;  <span class="comment">// 155
  </span>                                ,&quot;<span class="string">keep-with-previous</span>&quot;  <span class="comment">// 156
  </span>                    ,&quot;<span class="string">keep-with-previous.within-line</span>&quot;  <span class="comment">// 157
  </span>                  ,&quot;<span class="string">keep-with-previous.within-column</span>&quot;  <span class="comment">// 158
  </span>                    ,&quot;<span class="string">keep-with-previous.within-page</span>&quot;  <span class="comment">// 159
  </span>                                          ,&quot;<span class="string">language</span>&quot;  <span class="comment">// 160
  </span>                              ,&quot;<span class="string">last-line-end-indent</span>&quot;  <span class="comment">// 161
  </span>                                  ,&quot;<span class="string">leader-alignment</span>&quot;  <span class="comment">// 162
  </span>                                     ,&quot;<span class="string">leader-length</span>&quot;  <span class="comment">// 163
  </span>                             ,&quot;<span class="string">leader-length.minimum</span>&quot;  <span class="comment">// 164
  </span>                             ,&quot;<span class="string">leader-length.optimum</span>&quot;  <span class="comment">// 165
  </span>                             ,&quot;<span class="string">leader-length.maximum</span>&quot;  <span class="comment">// 166
  </span>                                    ,&quot;<span class="string">leader-pattern</span>&quot;  <span class="comment">// 167
  </span>                              ,&quot;<span class="string">leader-pattern-width</span>&quot;  <span class="comment">// 168
  </span>                                              ,&quot;<span class="string">left</span>&quot;  <span class="comment">// 169
  </span>                                    ,&quot;<span class="string">letter-spacing</span>&quot;  <span class="comment">// 170
  </span>                            ,&quot;<span class="string">letter-spacing.minimum</span>&quot;  <span class="comment">// 171
  </span>                            ,&quot;<span class="string">letter-spacing.optimum</span>&quot;  <span class="comment">// 172
  </span>                            ,&quot;<span class="string">letter-spacing.maximum</span>&quot;  <span class="comment">// 173
  </span>                     ,&quot;<span class="string">letter-spacing.conditionality</span>&quot;  <span class="comment">// 174
  </span>                         ,&quot;<span class="string">letter-spacing.precedence</span>&quot;  <span class="comment">// 175
  </span>                                      ,&quot;<span class="string">letter-value</span>&quot;  <span class="comment">// 176
  </span>                                ,&quot;<span class="string">linefeed-treatment</span>&quot;  <span class="comment">// 177
  </span>                                       ,&quot;<span class="string">line-height</span>&quot;  <span class="comment">// 178
  </span>                               ,&quot;<span class="string">line-height.minimum</span>&quot;  <span class="comment">// 179
  </span>                               ,&quot;<span class="string">line-height.optimum</span>&quot;  <span class="comment">// 180
  </span>                               ,&quot;<span class="string">line-height.maximum</span>&quot;  <span class="comment">// 181
  </span>                        ,&quot;<span class="string">line-height.conditionality</span>&quot;  <span class="comment">// 182
  </span>                            ,&quot;<span class="string">line-height.precedence</span>&quot;  <span class="comment">// 183
  </span>                      ,&quot;<span class="string">line-height-shift-adjustment</span>&quot;  <span class="comment">// 184
  </span>                            ,&quot;<span class="string">line-stacking-strategy</span>&quot;  <span class="comment">// 185
  </span>
                                   ,&quot;<span class="string">marker-class-name</span>&quot;  <span class="comment">// 186
  </span>                                       ,&quot;<span class="string">master-name</span>&quot;  <span class="comment">// 187
  </span>                                  ,&quot;<span class="string">master-reference</span>&quot;  <span class="comment">// 188
  </span>                                        ,&quot;<span class="string">max-height</span>&quot;  <span class="comment">// 189
  </span>                                   ,&quot;<span class="string">maximum-repeats</span>&quot;  <span class="comment">// 190
  </span>                                         ,&quot;<span class="string">max-width</span>&quot;  <span class="comment">// 191
  </span>                                       ,&quot;<span class="string">media-usage</span>&quot;  <span class="comment">// 192
  </span>                                        ,&quot;<span class="string">min-height</span>&quot;  <span class="comment">// 193
  </span>                                         ,&quot;<span class="string">min-width</span>&quot;  <span class="comment">// 194
  </span>                           ,&quot;<span class="string">number-columns-repeated</span>&quot;  <span class="comment">// 195
  </span>                               ,&quot;<span class="string">number-rows-spanned</span>&quot;  <span class="comment">// 196
  </span>                                       ,&quot;<span class="string">odd-or-even</span>&quot;  <span class="comment">// 197
  </span>                                           ,&quot;<span class="string">orphans</span>&quot;  <span class="comment">// 198
  </span>                                          ,&quot;<span class="string">overflow</span>&quot;  <span class="comment">// 199
  </span>
                                       ,&quot;<span class="string">padding-after</span>&quot;  <span class="comment">// 200
  </span>                              ,&quot;<span class="string">padding-after.length</span>&quot;  <span class="comment">// 201
  </span>                      ,&quot;<span class="string">padding-after.conditionality</span>&quot;  <span class="comment">// 202
  </span>                                    ,&quot;<span class="string">padding-before</span>&quot;  <span class="comment">// 203
  </span>                             ,&quot;<span class="string">padding-before.length</span>&quot;  <span class="comment">// 204
  </span>                     ,&quot;<span class="string">padding-before.conditionality</span>&quot;  <span class="comment">// 205
  </span>                                       ,&quot;<span class="string">padding-end</span>&quot;  <span class="comment">// 206
  </span>                                ,&quot;<span class="string">padding-end.length</span>&quot;  <span class="comment">// 207
  </span>                        ,&quot;<span class="string">padding-end.conditionality</span>&quot;  <span class="comment">// 208
  </span>                                     ,&quot;<span class="string">padding-start</span>&quot;  <span class="comment">// 209
  </span>                              ,&quot;<span class="string">padding-start.length</span>&quot;  <span class="comment">// 210
  </span>                      ,&quot;<span class="string">padding-start.conditionality</span>&quot;  <span class="comment">// 211
  </span>
                                      ,&quot;<span class="string">padding-bottom</span>&quot;  <span class="comment">// 212
  </span>                                      ,&quot;<span class="string">padding-left</span>&quot;  <span class="comment">// 213
  </span>                                     ,&quot;<span class="string">padding-right</span>&quot;  <span class="comment">// 214
  </span>                                       ,&quot;<span class="string">padding-top</span>&quot;  <span class="comment">// 215
  </span>
                                         ,&quot;<span class="string">page-height</span>&quot;  <span class="comment">// 216
  </span>                                     ,&quot;<span class="string">page-position</span>&quot;  <span class="comment">// 217
  </span>                                        ,&quot;<span class="string">page-width</span>&quot;  <span class="comment">// 218
  </span>                                       ,&quot;<span class="string">pause-after</span>&quot;  <span class="comment">// 219
  </span>                                      ,&quot;<span class="string">pause-before</span>&quot;  <span class="comment">// 220
  </span>                                             ,&quot;<span class="string">pitch</span>&quot;  <span class="comment">// 221
  </span>                                       ,&quot;<span class="string">pitch-range</span>&quot;  <span class="comment">// 222
  </span>                                       ,&quot;<span class="string">play-during</span>&quot;  <span class="comment">// 223
  </span>                                        ,&quot;<span class="string">precedence</span>&quot;  <span class="comment">// 224
  </span>               ,&quot;<span class="string">provisional-distance-between-starts</span>&quot;  <span class="comment">// 225
  </span>                      ,&quot;<span class="string">provisional-label-separation</span>&quot;  <span class="comment">// 226
  </span>                             ,&quot;<span class="string">reference-orientation</span>&quot;  <span class="comment">// 227
  </span>                                            ,&quot;<span class="string">ref-id</span>&quot;  <span class="comment">// 228
  </span>                                       ,&quot;<span class="string">region-name</span>&quot;  <span class="comment">// 229
  </span>                                    ,&quot;<span class="string">relative-align</span>&quot;  <span class="comment">// 230
  </span>                                 ,&quot;<span class="string">relative-position</span>&quot;  <span class="comment">// 231
  </span>                                  ,&quot;<span class="string">rendering-intent</span>&quot;  <span class="comment">// 232
  </span>                                 ,&quot;<span class="string">retrieve-boundary</span>&quot;  <span class="comment">// 233
  </span>                               ,&quot;<span class="string">retrieve-class-name</span>&quot;  <span class="comment">// 234
  </span>                                 ,&quot;<span class="string">retrieve-position</span>&quot;  <span class="comment">// 235
  </span>                                          ,&quot;<span class="string">richness</span>&quot;  <span class="comment">// 236
  </span>                                             ,&quot;<span class="string">right</span>&quot;  <span class="comment">// 237
  </span>                                              ,&quot;<span class="string">role</span>&quot;  <span class="comment">// 238
  </span>                                        ,&quot;<span class="string">rule-style</span>&quot;  <span class="comment">// 239
  </span>                                    ,&quot;<span class="string">rule-thickness</span>&quot;  <span class="comment">// 240
  </span>                                           ,&quot;<span class="string">scaling</span>&quot;  <span class="comment">// 241
  </span>                                    ,&quot;<span class="string">scaling-method</span>&quot;  <span class="comment">// 242
  </span>                                      ,&quot;<span class="string">score-spaces</span>&quot;  <span class="comment">// 243
  </span>                                            ,&quot;<span class="string">script</span>&quot;  <span class="comment">// 244
  </span>                                  ,&quot;<span class="string">show-destination</span>&quot;  <span class="comment">// 245
  </span>                                   ,&quot;<span class="string">source-document</span>&quot;  <span class="comment">// 246
  </span>
                                         ,&quot;<span class="string">space-after</span>&quot;  <span class="comment">// 247
  </span>                               ,&quot;<span class="string">space-after.minimum</span>&quot;  <span class="comment">// 248
  </span>                               ,&quot;<span class="string">space-after.optimum</span>&quot;  <span class="comment">// 249
  </span>                               ,&quot;<span class="string">space-after.maximum</span>&quot;  <span class="comment">// 250
  </span>                        ,&quot;<span class="string">space-after.conditionality</span>&quot;  <span class="comment">// 251
  </span>                            ,&quot;<span class="string">space-after.precedence</span>&quot;  <span class="comment">// 252
  </span>                                      ,&quot;<span class="string">space-before</span>&quot;  <span class="comment">// 253
  </span>                              ,&quot;<span class="string">space-before.minimum</span>&quot;  <span class="comment">// 254
  </span>                              ,&quot;<span class="string">space-before.optimum</span>&quot;  <span class="comment">// 255
  </span>                              ,&quot;<span class="string">space-before.maximum</span>&quot;  <span class="comment">// 256
  </span>                       ,&quot;<span class="string">space-before.conditionality</span>&quot;  <span class="comment">// 257
  </span>                           ,&quot;<span class="string">space-before.precedence</span>&quot;  <span class="comment">// 258
  </span>                                         ,&quot;<span class="string">space-end</span>&quot;  <span class="comment">// 259
  </span>                                 ,&quot;<span class="string">space-end.minimum</span>&quot;  <span class="comment">// 260
  </span>                                 ,&quot;<span class="string">space-end.optimum</span>&quot;  <span class="comment">// 261
  </span>                                 ,&quot;<span class="string">space-end.maximum</span>&quot;  <span class="comment">// 262
  </span>                          ,&quot;<span class="string">space-end.conditionality</span>&quot;  <span class="comment">// 263
  </span>                              ,&quot;<span class="string">space-end.precedence</span>&quot;  <span class="comment">// 264
  </span>                                       ,&quot;<span class="string">space-start</span>&quot;  <span class="comment">// 265
  </span>                               ,&quot;<span class="string">space-start.minimum</span>&quot;  <span class="comment">// 266
  </span>                               ,&quot;<span class="string">space-start.optimum</span>&quot;  <span class="comment">// 267
  </span>                               ,&quot;<span class="string">space-start.maximum</span>&quot;  <span class="comment">// 268
  </span>                        ,&quot;<span class="string">space-start.conditionality</span>&quot;  <span class="comment">// 269
  </span>                            ,&quot;<span class="string">space-start.precedence</span>&quot;  <span class="comment">// 270
  </span>
                                       ,&quot;<span class="string">margin-bottom</span>&quot;  <span class="comment">// 271
  </span>                                       ,&quot;<span class="string">margin-left</span>&quot;  <span class="comment">// 272
  </span>                                      ,&quot;<span class="string">margin-right</span>&quot;  <span class="comment">// 273
  </span>                                        ,&quot;<span class="string">margin-top</span>&quot;  <span class="comment">// 274
  </span>
                                                ,&quot;<span class="string">span</span>&quot;  <span class="comment">// 275
  </span>                                             ,&quot;<span class="string">speak</span>&quot;  <span class="comment">// 276
  </span>                                      ,&quot;<span class="string">speak-header</span>&quot;  <span class="comment">// 277
  </span>                                     ,&quot;<span class="string">speak-numeral</span>&quot;  <span class="comment">// 278
  </span>                                 ,&quot;<span class="string">speak-punctuation</span>&quot;  <span class="comment">// 279
  </span>                                       ,&quot;<span class="string">speech-rate</span>&quot;  <span class="comment">// 280
  </span>                                               ,&quot;<span class="string">src</span>&quot;  <span class="comment">// 281
  </span>                                      ,&quot;<span class="string">start-indent</span>&quot;  <span class="comment">// 282
  </span>                                    ,&quot;<span class="string">starting-state</span>&quot;  <span class="comment">// 283
  </span>                                        ,&quot;<span class="string">starts-row</span>&quot;  <span class="comment">// 284
  </span>                                            ,&quot;<span class="string">stress</span>&quot;  <span class="comment">// 285
  </span>                            ,&quot;<span class="string">suppress-at-line-break</span>&quot;  <span class="comment">// 286
  </span>                                         ,&quot;<span class="string">switch-to</span>&quot;  <span class="comment">// 287
  </span>                                      ,&quot;<span class="string">table-layout</span>&quot;  <span class="comment">// 288
  </span>                        ,&quot;<span class="string">table-omit-footer-at-break</span>&quot;  <span class="comment">// 289
  </span>                        ,&quot;<span class="string">table-omit-header-at-break</span>&quot;  <span class="comment">// 290
  </span>                       ,&quot;<span class="string">target-presentation-context</span>&quot;  <span class="comment">// 291
  </span>                         ,&quot;<span class="string">target-processing-context</span>&quot;  <span class="comment">// 292
  </span>                                 ,&quot;<span class="string">target-stylesheet</span>&quot;  <span class="comment">// 293
  </span>                                        ,&quot;<span class="string">text-align</span>&quot;  <span class="comment">// 294
  </span>                                   ,&quot;<span class="string">text-align-last</span>&quot;  <span class="comment">// 295
  </span>                                     ,&quot;<span class="string">text-altitude</span>&quot;  <span class="comment">// 296
  </span>                                   ,&quot;<span class="string">text-decoration</span>&quot;  <span class="comment">// 297
  </span>                                        ,&quot;<span class="string">text-depth</span>&quot;  <span class="comment">// 298
  </span>                                       ,&quot;<span class="string">text-indent</span>&quot;  <span class="comment">// 299
  </span>                                       ,&quot;<span class="string">text-shadow</span>&quot;  <span class="comment">// 300
  </span>                                    ,&quot;<span class="string">text-transform</span>&quot;  <span class="comment">// 301
  </span>                                               ,&quot;<span class="string">top</span>&quot;  <span class="comment">// 302
  </span>                               ,&quot;<span class="string">treat-as-word-space</span>&quot;  <span class="comment">// 303
  </span>                                      ,&quot;<span class="string">unicode-bidi</span>&quot;  <span class="comment">// 304
  </span>           ,&quot;<span class="string">usage-context-of-suppress-at-line-break</span>&quot;  <span class="comment">// 305
  </span>                                        ,&quot;<span class="string">visibility</span>&quot;  <span class="comment">// 306
  </span>                                      ,&quot;<span class="string">voice-family</span>&quot;  <span class="comment">// 307
  </span>                                            ,&quot;<span class="string">volume</span>&quot;  <span class="comment">// 308
  </span>                              ,&quot;<span class="string">white-space-collapse</span>&quot;  <span class="comment">// 309
  </span>                             ,&quot;<span class="string">white-space-treatment</span>&quot;  <span class="comment">// 310
  </span>                                            ,&quot;<span class="string">widows</span>&quot;  <span class="comment">// 311
  </span>                                             ,&quot;<span class="string">width</span>&quot;  <span class="comment">// 312
  </span>                                      ,&quot;<span class="string">word-spacing</span>&quot;  <span class="comment">// 313
  </span>                              ,&quot;<span class="string">word-spacing-minimum</span>&quot;  <span class="comment">// 314
  </span>                              ,&quot;<span class="string">word-spacing-optimum</span>&quot;  <span class="comment">// 315
  </span>                              ,&quot;<span class="string">word-spacing-maximum</span>&quot;  <span class="comment">// 316
  </span>                       ,&quot;<span class="string">word-spacing-conditionality</span>&quot;  <span class="comment">// 317
  </span>                           ,&quot;<span class="string">word-spacing-precedence</span>&quot;  <span class="comment">// 318
  </span>                                       ,&quot;<span class="string">wrap-option</span>&quot;  <span class="comment">// 319
  </span>                                           ,&quot;<span class="string">z-index</span>&quot;  <span class="comment">// 320
  </span>    };
  
      <span class="comment">/**
       * A &lt;tt&gt;hashMap&lt;/tt&gt; mapping property names (the keys) to
       * property integer indices.
       */</span>
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">HashMap</span> <span class="variable-name" id="toIndex">toIndex</span>;
      <span class="jde-java-font-lock-modifier">static</span> {
          toIndex = <span class="keyword">new</span> <span class="type">HashMap</span>(<span class="jde-java-font-lock-constant">LAST_PROPERTY_INDEX</span> + <span class="jde-java-font-lock-number">1</span>);
          <span class="comment">// Set up the toIndex Hashmap with the name of the
  </span>        <span class="comment">// property as a key, and the integer index as a value
  </span>        <span class="keyword">for</span> (<span class="type">int</span> <span class="variable-name" id="i">i</span> = <span class="jde-java-font-lock-number">0</span>; i &lt;= <span class="jde-java-font-lock-constant">LAST_PROPERTY_INDEX</span>; i++) {
              <span class="keyword">if</span> (toIndex.put(propertyNames[i],
                                      Ints.consts.get(i)) != <span class="jde-java-font-lock-constant" id="null">null</span>) {
                  <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">RuntimeException</span>(
                      &quot;<span class="string">Duplicate values in toIndex for key </span>&quot; +
                      propertyNames[i]);
              }
          }
      }
  
      <span class="comment">/**
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="propindex">propindex</span><span class="comment"> &lt;tt&gt;int&lt;/tt&gt; index of the FO property.
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> &lt;tt&gt;String&lt;/tt&gt; name of the indexd FO property.
       * </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">PropertyException</span><span class="comment"> if the property index is invalid.
       */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="type">String</span> <span class="function-name" id="getPropertyName">getPropertyName</span>(<span class="type">int</span> <span class="variable-name">propindex</span>)
                  <span class="keyword">throws</span> <span class="type">PropertyException</span>
      {
          <span class="keyword">if</span> (propindex &lt; <span class="jde-java-font-lock-number">0</span> || propindex &gt; <span class="jde-java-font-lock-constant">LAST_PROPERTY_INDEX</span>)
                  <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>
                          (&quot;<span class="string">getPropertyName: index is invalid: </span>&quot; + propindex);
          <span class="keyword">return</span> propertyNames[propindex];
      }
  
      <span class="comment">/**
       * Get the property index of a property name.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">propindex</span><span class="comment"> &lt;tt&gt;int&lt;/tt&gt; index of the FO property.
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> &lt;tt&gt;String&lt;/tt&gt; name of the indexd FO property.
       * </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">PropertyException</span><span class="comment"> if the property index is invalid.
       */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="type">int</span> <span class="function-name" id="getPropertyIndex">getPropertyIndex</span>(<span class="type">String</span> <span class="variable-name" id="name">name</span>)
          <span class="keyword">throws</span> <span class="type">PropertyException</span>
      {
          <span class="type">Integer</span> <span class="variable-name" id="intg">intg</span> = (<span class="type">Integer</span>)(toIndex.get(name));
          <span class="keyword">if</span> (intg == <span class="jde-java-font-lock-constant">null</span>)
              <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>
                                  (&quot;<span class="string">Property name '</span>&quot; + name + &quot;<span class="string">' is unknown.</span>&quot;);
          <span class="keyword">return</span> intg.intValue();
      }
  
  }
  </pre>
    </body>
  </html>
  
  
  
  1.1                  xml-site/targets/fop/design/alt.design/properties/RenderingIntent.html
  
  Index: RenderingIntent.html
  ===================================================================
  <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN">
  <!-- Created by htmlize-0.67 in css mode. -->
  <html>
    <head>
      <title>RenderingIntent.java</title>
      <style type="text/css">
      <!--
        body {
          color: #000000;
          background-color: #faf0e6;
        } /* default */
        .variable-name {
          color: #8b008b;
          background-color: #faf0e6;
        } /* font-lock-variable-name-face */
        .jde-java-font-lock-package {
          color: #0000cd;
          background-color: #faf0e6;
        } /* jde-java-font-lock-package-face */
        .jde-java-font-lock-constant {
          color: #5f9ea0;
          background-color: #faf0e6;
        } /* jde-java-font-lock-constant-face */
        .keyword {
          color: #8b0000;
          background-color: #faf0e6;
        } /* font-lock-keyword-face */
        .string {
          color: #008b00;
          background-color: #faf0e6;
        } /* font-lock-string-face */
        .jde-java-font-lock-number {
          color: #bc8f8f;
          background-color: #faf0e6;
        } /* jde-java-font-lock-number-face */
        .type {
          color: #4682b4;
          background-color: #faf0e6;
        } /* font-lock-type-face */
        .jde-java-font-lock-modifier {
          color: #da70d6;
          background-color: #faf0e6;
        } /* jde-java-font-lock-modifier-face */
        .function-name {
          color: #8b2323;
          background-color: #faf0e6;
        } /* font-lock-function-name-face */
        a {
          color: inherit;
          background-color: inherit;
          font: inherit;
          text-decoration: inherit;
        }
        a:hover {
          text-decoration: underline;
        }
      -->
      </style>
    </head>
    <body>
      <pre>
  <span class="keyword">package</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="jde-java-font-lock-package">properties</span>;
  
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="jde-java-font-lock-package">expr</span>.<span class="type">PropertyException</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datastructs</span>.<span class="type">ROStringArray</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">Ints</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="jde-java-font-lock-package">properties</span>.<span class="type">Property</span>;
  
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">java</span>.<span class="jde-java-font-lock-package">util</span>.<span class="type">Map</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">java</span>.<span class="jde-java-font-lock-package">util</span>.<span class="type">HashMap</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">java</span>.<span class="jde-java-font-lock-package">util</span>.<span class="type">Collections</span>;
  
  <span class="jde-java-font-lock-modifier">public</span> <span class="keyword">class</span> <span class="function-name" id="RenderingIntentClass">RenderingIntent</span> <span class="keyword">extends</span> <span class="type">Property</span>  {
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span> <span class="variable-name" id="dataTypes">dataTypes</span> = <span class="jde-java-font-lock-constant" id="AUTO">AUTO</span> | <span class="jde-java-font-lock-constant">ENUM</span> | <span class="jde-java-font-lock-constant">INHERIT</span>;
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span> <span class="variable-name" id="traitMapping">traitMapping</span> = <span class="jde-java-font-lock-constant" id="FORMATTING">FORMATTING</span>;
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span> <span class="variable-name" id="initialValueType">initialValueType</span> = <span class="jde-java-font-lock-constant" id="AUTO_IT">AUTO_IT</span>;
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span> <span class="variable-name" id="PERCEPTUAL">PERCEPTUAL</span> = <span class="jde-java-font-lock-number">1</span>;
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span> <span class="variable-name" id="RELATIVE_COLORIMETRIC">RELATIVE_COLORIMETRIC</span> = <span class="jde-java-font-lock-number">2</span>;
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span> <span class="variable-name" id="SATURATION">SATURATION</span> = <span class="jde-java-font-lock-number">3</span>;
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span> <span class="variable-name" id="ABSOLUTE_COLORIMETRIC">ABSOLUTE_COLORIMETRIC</span> = <span class="jde-java-font-lock-number">4</span>;
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span> <span class="variable-name" id="inherited">inherited</span> = <span class="jde-java-font-lock-constant" id="NO">NO</span>;
  
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">String</span>[] <span class="variable-name" id="rwEnums">rwEnums</span> = {
          <span class="jde-java-font-lock-constant" id="null">null</span>
          ,&quot;<span class="string">perceptual</span>&quot;
          ,&quot;<span class="string">relative-colorimetric</span>&quot;
          ,&quot;<span class="string">saturation</span>&quot;
          ,&quot;<span class="string">absolute-colorimetric</span>&quot;
      };
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">HashMap</span> <span class="variable-name" id="rwEnumHash">rwEnumHash</span>;
      <span class="jde-java-font-lock-modifier">static</span> {
          rwEnumHash = <span class="keyword">new</span> <span class="type">HashMap</span>(rwEnums.length);
          <span class="keyword">for</span> (<span class="type">int</span> <span class="variable-name" id="i">i</span> = <span class="jde-java-font-lock-number">1</span>; i &lt; rwEnums.length; i++ ) {
              rwEnumHash.put((<span class="type">Object</span>)rwEnums[i],
                                  (<span class="type">Object</span>) Ints.consts.get(i));
          }
      }
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">int</span> <span class="function-name" id="getEnumIndex">getEnumIndex</span>(<span class="type">String</span> <span class="variable-name" id="enum">enum</span>)
          <span class="keyword">throws</span> <span class="type">PropertyException</span>
      {
          <span class="type">Integer</span> <span class="variable-name" id="ii">ii</span> = (<span class="type">Integer</span>)(rwEnumHash.get(enum));
          <span class="keyword">if</span> (ii == <span class="jde-java-font-lock-constant">null</span>)
              <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(&quot;<span class="string">Unknown enum value: </span>&quot; + enum);
          <span class="keyword">return</span> ii.intValue();
      }
      <span class="jde-java-font-lock-modifier">public</span> <span class="type">String</span> <span class="function-name" id="getEnumText">getEnumText</span>(<span class="type">int</span> <span class="variable-name" id="index">index</span>)
          <span class="keyword">throws</span> <span class="type">PropertyException</span>
      {
          <span class="keyword">if</span> (index &lt; <span class="jde-java-font-lock-number">1</span> || index &gt;= rwEnums.length)
              <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(&quot;<span class="string">index out of range: </span>&quot; + index);
          <span class="keyword">return</span> rwEnums[index];
      }
  }
  
  </pre>
    </body>
  </html>
  
  
  
  1.1                  xml-site/targets/fop/design/alt.design/properties/ShorthandPropSets.html
  
  Index: ShorthandPropSets.html
  ===================================================================
  <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN">
  <!-- Created by htmlize-0.67 in css mode. -->
  <html>
    <head>
      <title>ShorthandPropSets.java</title>
      <style type="text/css">
      <!--
        body {
          color: #000000;
          background-color: #faf0e6;
        } /* default */
        .reference {
          color: #cd0000;
          background-color: #faf0e6;
        } /* font-lock-reference-face */
        .function-name {
          color: #8b2323;
          background-color: #faf0e6;
        } /* font-lock-function-name-face */
        .jde-java-font-lock-italic {
          background-color: #faf0e6;
          font-style: italic;
        } /* jde-java-font-lock-italic-face */
        .jde-java-font-lock-modifier {
          color: #da70d6;
          background-color: #faf0e6;
        } /* jde-java-font-lock-modifier-face */
        .keyword {
          color: #8b0000;
          background-color: #faf0e6;
        } /* font-lock-keyword-face */
        .jde-java-font-lock-link {
          color: #0000ff;
          background-color: #faf0e6;
          text-decoration: underline;
        } /* jde-java-font-lock-link-face */
        .variable-name {
          color: #8b008b;
          background-color: #faf0e6;
        } /* font-lock-variable-name-face */
        .string {
          color: #008b00;
          background-color: #faf0e6;
        } /* font-lock-string-face */
        .jde-java-font-lock-package {
          color: #0000cd;
          background-color: #faf0e6;
        } /* jde-java-font-lock-package-face */
        .jde-java-font-lock-constant {
          color: #5f9ea0;
          background-color: #faf0e6;
        } /* jde-java-font-lock-constant-face */
        .type {
          color: #4682b4;
          background-color: #faf0e6;
        } /* font-lock-type-face */
        .jde-java-font-lock-bold {
          background-color: #faf0e6;
          font-weight: bold;
        } /* jde-java-font-lock-bold-face */
        .jde-java-font-lock-doc-tag {
          color: #008b00;
          background-color: #faf0e6;
        } /* jde-java-font-lock-doc-tag-face */
        .comment {
          color: #00008b;
          background-color: #faf0e6;
        } /* font-lock-comment-face */
        .jde-java-font-lock-number {
          color: #bc8f8f;
          background-color: #faf0e6;
        } /* jde-java-font-lock-number-face */
        a {
          color: inherit;
          background-color: inherit;
          font: inherit;
          text-decoration: inherit;
        }
        a:hover {
          text-decoration: underline;
        }
      -->
      </style>
    </head>
    <body>
      <pre>
  <span class="comment">/**
   * $Id: ShorthandPropSets.html,v 1.1 2003/01/24 10:46:48 pbwest Exp $
   * &lt;br/&gt;Copyright (C) 2001 The Apache Software Foundation. All rights reserved.
   * &lt;br/&gt;For details on use and redistribution please refer to the
   * &lt;br/&gt;LICENSE file included with these sources.
   *
   * </span><span class="jde-java-font-lock-doc-tag">@author</span><span class="comment"> &lt;a href=&quot;mailto:pbwest@powerup.com.au&quot;&gt;</span><span class="jde-java-font-lock-link">Peter B. West</span><span class="comment">&lt;/a&gt;
   * </span><span class="jde-java-font-lock-doc-tag">@version</span><span class="comment"> $Revision: 1.1 $ $Name:  $
   */</span>
  
  <span class="keyword">package</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>;
  
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">java</span>.<span class="jde-java-font-lock-package">lang</span>.<span class="type">CloneNotSupportedException</span>;
  
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">java</span>.<span class="jde-java-font-lock-package">util</span>.<span class="type">Set</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">java</span>.<span class="jde-java-font-lock-package">util</span>.<span class="type">BitSet</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">java</span>.<span class="jde-java-font-lock-package">util</span>.<span class="type">HashSet</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">java</span>.<span class="jde-java-font-lock-package">util</span>.<span class="type">HashMap</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">java</span>.<span class="jde-java-font-lock-package">util</span>.<span class="type">List</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">java</span>.<span class="jde-java-font-lock-package">util</span>.<span class="type">ListIterator</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">java</span>.<span class="jde-java-font-lock-package">util</span>.<span class="type">Iterator</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">java</span>.<span class="jde-java-font-lock-package">util</span>.<span class="type">Arrays</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">java</span>.<span class="jde-java-font-lock-package">util</span>.<span class="type">Collections</span>;
  
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="jde-java-font-lock-package">expr</span>.<span class="type">PropertyException</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">PropertyValue</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">PropertyValueList</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="type">PropNames</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="type">PropertyConsts</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datastructs</span>.<span class="type">ROIntArray</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datastructs</span>.<span class="type">ROBitSet</span>;
  <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">Ints</span>;
  
  <span class="comment">/**
   * This class contains &lt;tt&gt;ROIntArray&lt;/tt&gt;s which encode the various sets of
   * properties into which the shorthand and compound properties expand, and
   * utility methods for manipulating these expansions.
   */</span>
  <span class="jde-java-font-lock-modifier">public</span> <span class="keyword">class</span> <span class="function-name" id="ShorthandPropSetsClass">ShorthandPropSets</span> {
  
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">String</span> <span class="variable-name" id="tag">tag</span> = &quot;<span class="string">$Name:  $</span>&quot;;
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">String</span> <span class="variable-name" id="revision">revision</span> = &quot;<span class="string">$Revision: 1.1 $</span>&quot;;
  
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">String</span> <span class="variable-name" id="packageName">packageName</span> = &quot;<span class="string">org.apache.fop.fo</span>&quot;;
  
  
      <span class="comment">// My preference here for shorthands which expand to compound properties
  </span>    <span class="comment">// would be to expand only to the compound, and allow compounds to be
  </span>    <span class="comment">// &quot;normally&quot; expanded in a second step.  Unfortunately, the shorthand
  </span>    <span class="comment">// border-spacing expands (potentially) into both of the elements of
  </span>    <span class="comment">// the border-separation compound.  However, other compound expansions
  </span>    <span class="comment">// are defined with only a single value for the compound, so I will
  </span>    <span class="comment">// treat border-separation as a special case in the event that two
  </span>    <span class="comment">// values are provided.
  </span>    <span class="comment">// I''m not sure whether a shorthand specification which sets a compound
  </span>    <span class="comment">// property with a single top-level value should be regarded as a
  </span>    <span class="comment">// specification for the purposes of inheritance, but I will assume so
  </span>    <span class="comment">// until further notice.
  </span>    <span class="comment">// pbw
  </span>
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span>[] <span class="variable-name" id="backgroundPosition">backgroundPosition</span> = {
          <span class="reference">PropNames</span>.<span class="type">BACKGROUND_POSITION_HORIZONTAL</span>
          ,<span class="reference">PropNames</span>.<span class="type">BACKGROUND_POSITION_VERTICAL</span>
      };
  
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span>[] <span class="variable-name" id="borderColor">borderColor</span> = {
          <span class="reference">PropNames</span>.<span class="type">BORDER_TOP_COLOR</span>
          ,<span class="reference">PropNames</span>.<span class="type">BORDER_RIGHT_COLOR</span>
          ,<span class="reference">PropNames</span>.<span class="type">BORDER_BOTTOM_COLOR</span>
          ,<span class="reference">PropNames</span>.<span class="type">BORDER_LEFT_COLOR</span>
      };
  
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span>[] <span class="variable-name" id="borderStyle">borderStyle</span> = {
          <span class="reference">PropNames</span>.<span class="type">BORDER_TOP_STYLE</span>
          ,<span class="reference">PropNames</span>.<span class="type">BORDER_RIGHT_STYLE</span>
          ,<span class="reference">PropNames</span>.<span class="type">BORDER_BOTTOM_STYLE</span>
          ,<span class="reference">PropNames</span>.<span class="type">BORDER_LEFT_STYLE</span>
      };
  
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span>[] <span class="variable-name" id="borderWidth">borderWidth</span> = {
          <span class="reference">PropNames</span>.<span class="type">BORDER_TOP_WIDTH</span>
          ,<span class="reference">PropNames</span>.<span class="type">BORDER_RIGHT_WIDTH</span>
          ,<span class="reference">PropNames</span>.<span class="type">BORDER_BOTTOM_WIDTH</span>
          ,<span class="reference">PropNames</span>.<span class="type">BORDER_LEFT_WIDTH</span>
      };
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="backgroundExpansion">backgroundExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(<span class="keyword">new</span> <span class="type">int</span>[][] {
              <span class="keyword">new</span> <span class="type">int</span>[] {
                  <span class="reference">PropNames</span>.<span class="type">BACKGROUND_COLOR</span>
                  ,<span class="reference">PropNames</span>.<span class="type">BACKGROUND_IMAGE</span>
                  ,<span class="reference">PropNames</span>.<span class="type">BACKGROUND_REPEAT</span>
                  ,<span class="reference">PropNames</span>.<span class="type">BACKGROUND_ATTACHMENT</span>
                  ,<span class="reference">PropNames</span>.<span class="type">BACKGROUND_POSITION_HORIZONTAL</span>
                  ,<span class="reference">PropNames</span>.<span class="type">BACKGROUND_POSITION_VERTICAL</span>
              }, backgroundPosition});
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="backgroundPositionExpansion">backgroundPositionExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(backgroundPosition);
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="borderExpansion">borderExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(<span class="keyword">new</span> <span class="type">int</span>[][] { borderStyle, borderColor, borderWidth });
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="borderStyleExpansion">borderStyleExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(borderStyle);
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="borderColorExpansion">borderColorExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(borderColor);
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="borderWidthExpansion">borderWidthExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(borderWidth);
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="borderTopExpansion">borderTopExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(<span class="keyword">new</span> <span class="type">int</span>[] {
              <span class="reference">PropNames</span>.<span class="type">BORDER_TOP_STYLE</span>
              ,<span class="reference">PropNames</span>.<span class="type">BORDER_TOP_COLOR</span>
              ,<span class="reference">PropNames</span>.<span class="type">BORDER_TOP_WIDTH</span>
          });
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="borderRightExpansion">borderRightExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(<span class="keyword">new</span> <span class="type">int</span>[] {
              <span class="reference">PropNames</span>.<span class="type">BORDER_RIGHT_STYLE</span>
              ,<span class="reference">PropNames</span>.<span class="type">BORDER_RIGHT_COLOR</span>
              ,<span class="reference">PropNames</span>.<span class="type">BORDER_RIGHT_WIDTH</span>
          });
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="borderBottomExpansion">borderBottomExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(<span class="keyword">new</span> <span class="type">int</span>[] {
              <span class="reference">PropNames</span>.<span class="type">BORDER_BOTTOM_STYLE</span>
              ,<span class="reference">PropNames</span>.<span class="type">BORDER_BOTTOM_COLOR</span>
              ,<span class="reference">PropNames</span>.<span class="type">BORDER_BOTTOM_WIDTH</span>
          });
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="borderLeftExpansion">borderLeftExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(<span class="keyword">new</span> <span class="type">int</span>[] {
              <span class="reference">PropNames</span>.<span class="type">BORDER_LEFT_STYLE</span>
              ,<span class="reference">PropNames</span>.<span class="type">BORDER_LEFT_COLOR</span>
              ,<span class="reference">PropNames</span>.<span class="type">BORDER_LEFT_WIDTH</span>
          });
  
      <span class="comment">/**
       * Watch this one.  &lt;i&gt;</span><span class="jde-java-font-lock-italic">border-spacing</span><span class="comment">&lt;/i&gt; is a shorthand which expands
       * into the components of the &lt;tt&gt;&amp;lt;border-separation&amp;gt;&lt;/tt&gt; compound
       * property.
       */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="borderSpacingExpansion">borderSpacingExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(<span class="keyword">new</span> <span class="type">int</span>[] {
              <span class="reference">PropNames</span>.<span class="type">BORDER_SEPARATION</span>
          });
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="cueExpansion">cueExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(<span class="keyword">new</span> <span class="type">int</span>[] {
              <span class="reference">PropNames</span>.<span class="type">CUE_BEFORE</span>
              ,<span class="reference">PropNames</span>.<span class="type">CUE_AFTER</span>
          });
  
      <span class="comment">/**
       * Another nasty one.  &lt;i&gt;</span><span class="jde-java-font-lock-italic">font</span><span class="comment">&lt;/i&gt; expands, in part, into
       * &lt;i&gt;</span><span class="jde-java-font-lock-italic">line-height</span><span class="comment">&lt;/i&gt;, which is itself a compound property with a
       * &lt;tt&gt;&amp;lt;space&amp;gt;&lt;/tt&gt; value.
       */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="fontExpansion">fontExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(<span class="keyword">new</span> <span class="type">int</span>[] {
              <span class="reference">PropNames</span>.<span class="type">FONT_FAMILY</span>
              ,<span class="reference">PropNames</span>.<span class="type">FONT_STYLE</span>
              ,<span class="reference">PropNames</span>.<span class="type">FONT_VARIANT</span>
              ,<span class="reference">PropNames</span>.<span class="type">FONT_WEIGHT</span>
              ,<span class="reference">PropNames</span>.<span class="type">FONT_SIZE</span>
              ,<span class="reference">PropNames</span>.<span class="type">LINE_HEIGHT</span>
              ,<span class="reference">PropNames</span>.<span class="type">FONT_SIZE_ADJUST</span>
              ,<span class="reference">PropNames</span>.<span class="type">FONT_STRETCH</span>
              ,<span class="reference">PropNames</span>.<span class="type">FONT_SELECTION_STRATEGY</span>
          });
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="marginExpansion">marginExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(<span class="keyword">new</span> <span class="type">int</span>[] {
              <span class="reference">PropNames</span>.<span class="type">MARGIN_TOP</span>
              ,<span class="reference">PropNames</span>.<span class="type">MARGIN_RIGHT</span>
              ,<span class="reference">PropNames</span>.<span class="type">MARGIN_BOTTOM</span>
              ,<span class="reference">PropNames</span>.<span class="type">MARGIN_LEFT</span>
          });
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="paddingExpansion">paddingExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(<span class="keyword">new</span> <span class="type">int</span>[] {
              <span class="reference">PropNames</span>.<span class="type">PADDING_TOP</span>
              ,<span class="reference">PropNames</span>.<span class="type">PADDING_RIGHT</span>
              ,<span class="reference">PropNames</span>.<span class="type">PADDING_BOTTOM</span>
              ,<span class="reference">PropNames</span>.<span class="type">PADDING_LEFT</span>
          });
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="pageBreakAfterExpansion">pageBreakAfterExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(<span class="keyword">new</span> <span class="type">int</span>[] {
              <span class="reference">PropNames</span>.<span class="type">BREAK_AFTER</span>
              ,<span class="reference">PropNames</span>.<span class="type">KEEP_WITH_NEXT</span>
          });
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="pageBreakBeforeExpansion">pageBreakBeforeExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(<span class="keyword">new</span> <span class="type">int</span>[] {
              <span class="reference">PropNames</span>.<span class="type">BREAK_BEFORE</span>
              ,<span class="reference">PropNames</span>.<span class="type">KEEP_WITH_PREVIOUS</span>
          });
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="pageBreakInsideExpansion">pageBreakInsideExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(<span class="keyword">new</span> <span class="type">int</span>[] {
              <span class="reference">PropNames</span>.<span class="type">KEEP_TOGETHER</span>
          });
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="pauseExpansion">pauseExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(<span class="keyword">new</span> <span class="type">int</span>[] {
              <span class="reference">PropNames</span>.<span class="type">PAUSE_BEFORE</span>
              ,<span class="reference">PropNames</span>.<span class="type">PAUSE_AFTER</span>
          });
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="positionExpansion">positionExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(<span class="keyword">new</span> <span class="type">int</span>[] {
              <span class="reference">PropNames</span>.<span class="type">RELATIVE_POSITION</span>
              ,<span class="reference">PropNames</span>.<span class="type">ABSOLUTE_POSITION</span>
          });
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="sizeExpansion">sizeExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(<span class="keyword">new</span> <span class="type">int</span>[] {
              <span class="reference">PropNames</span>.<span class="type">PAGE_HEIGHT</span>
              ,<span class="reference">PropNames</span>.<span class="type">PAGE_WIDTH</span>
          });
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="verticalAlignExpansion">verticalAlignExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(<span class="keyword">new</span> <span class="type">int</span>[] {
              <span class="reference">PropNames</span>.<span class="type">ALIGNMENT_BASELINE</span>
              ,<span class="reference">PropNames</span>.<span class="type">ALIGNMENT_ADJUST</span>
              ,<span class="reference">PropNames</span>.<span class="type">BASELINE_SHIFT</span>
              ,<span class="reference">PropNames</span>.<span class="type">DOMINANT_BASELINE</span>
          });
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="whiteSpaceExpansion">whiteSpaceExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(<span class="keyword">new</span> <span class="type">int</span>[] {
              <span class="reference">PropNames</span>.<span class="type">LINEFEED_TREATMENT</span>
              ,<span class="reference">PropNames</span>.<span class="type">WHITE_SPACE_COLLAPSE</span>
              ,<span class="reference">PropNames</span>.<span class="type">WHITE_SPACE_TREATMENT</span>
              ,<span class="reference">PropNames</span>.<span class="type">WRAP_OPTION</span>
          });
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="xmlLangExpansion">xmlLangExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(<span class="keyword">new</span> <span class="type">int</span>[] {
              <span class="reference">PropNames</span>.<span class="type">COUNTRY</span>
              ,<span class="reference">PropNames</span>.<span class="type">LANGUAGE</span>
          });
  
      <span class="comment">/**
       * Shorthand properties.  Where properties interact, they are listed
       * in increasing precision.
       */</span>
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span>[] <span class="variable-name" id="shorthands">shorthands</span> = {
              <span class="reference">PropNames</span>.<span class="type">BACKGROUND</span>
              ,<span class="reference">PropNames</span>.<span class="type">BACKGROUND_POSITION</span>
              ,<span class="reference">PropNames</span>.<span class="type">BORDER</span>
              ,<span class="reference">PropNames</span>.<span class="type">BORDER_STYLE</span>
              ,<span class="reference">PropNames</span>.<span class="type">BORDER_COLOR</span>
              ,<span class="reference">PropNames</span>.<span class="type">BORDER_WIDTH</span>
              ,<span class="reference">PropNames</span>.<span class="type">BORDER_TOP</span>
              ,<span class="reference">PropNames</span>.<span class="type">BORDER_RIGHT</span>
              ,<span class="reference">PropNames</span>.<span class="type">BORDER_BOTTOM</span>
              ,<span class="reference">PropNames</span>.<span class="type">BORDER_LEFT</span>
              ,<span class="reference">PropNames</span>.<span class="type">BORDER_SPACING</span>
              ,<span class="reference">PropNames</span>.<span class="type">CUE</span>
              ,<span class="reference">PropNames</span>.<span class="type">FONT</span>
              ,<span class="reference">PropNames</span>.<span class="type">MARGIN</span>
              ,<span class="reference">PropNames</span>.<span class="type">PADDING</span>
              ,<span class="reference">PropNames</span>.<span class="type">PAGE_BREAK_AFTER</span>
              ,<span class="reference">PropNames</span>.<span class="type">PAGE_BREAK_BEFORE</span>
              ,<span class="reference">PropNames</span>.<span class="type">PAGE_BREAK_INSIDE</span>
              ,<span class="reference">PropNames</span>.<span class="type">PAUSE</span>
              ,<span class="reference">PropNames</span>.<span class="type">POSITION</span>
              ,<span class="reference">PropNames</span>.<span class="type">SIZE</span>
              ,<span class="reference">PropNames</span>.<span class="type">VERTICAL_ALIGN</span>
              ,<span class="reference">PropNames</span>.<span class="type">WHITE_SPACE</span>
              ,<span class="reference">PropNames</span>.<span class="type">XML_LANG</span>
          };
  
      <span class="comment">/**
       * Array of &lt;i&gt;</span><span class="jde-java-font-lock-italic">ROIntArray&lt;/i&gt;&lt;b&gt;</span><span class="jde-java-font-lock-bold"> in same order as &lt;i&gt;shorthands&lt;/i&gt;</span><span class="comment">&lt;/b&gt;
       * &lt;i&gt;</span><span class="jde-java-font-lock-italic">ROIntArray</span><span class="comment">&lt;/i&gt;.
       * If a public view of this is required, use
       * Collections.unmodifiableList(Arrays.asList(shorthandExpansions))
       */</span>
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span>[] <span class="variable-name" id="shorthandExpansions">shorthandExpansions</span> = {
          backgroundExpansion
          ,backgroundPositionExpansion
          ,borderExpansion
          ,borderStyleExpansion
          ,borderColorExpansion
          ,borderWidthExpansion
          ,borderTopExpansion
          ,borderRightExpansion
          ,borderBottomExpansion
          ,borderLeftExpansion
          ,borderSpacingExpansion
          ,cueExpansion
          ,fontExpansion
          ,marginExpansion
          ,paddingExpansion
          ,pageBreakAfterExpansion
          ,pageBreakBeforeExpansion
          ,pageBreakInsideExpansion
          ,pauseExpansion
          ,positionExpansion
          ,sizeExpansion
          ,verticalAlignExpansion
          ,whiteSpaceExpansion
          ,xmlLangExpansion
      };
  
      <span class="comment">/**
       * Map property index to shorthand array index
       */</span>
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">HashMap</span> <span class="variable-name" id="shorthandMap">shorthandMap</span>;
      <span class="jde-java-font-lock-modifier">static</span> {
          shorthandMap = <span class="keyword">new</span> <span class="type">HashMap</span>(shorthands.length);
          <span class="keyword">for</span> (<span class="type">int</span> <span class="variable-name" id="i">i</span> = <span class="jde-java-font-lock-number">0</span>; i &lt; shorthands.length; i++) {
              shorthandMap.put
                      ((<span class="type">Object</span>)(Ints.consts.get(shorthands[i])), 
                       (<span class="type">Object</span>)(Ints.consts.get(i)));
          }
      }
  
      <span class="comment">/**
       * RO Shorthand properties.
       */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="roShorthands">roShorthands</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(shorthands);
  
      <span class="comment">/**
       * A &lt;tt&gt;ROBitSet&lt;/tt&gt; of the shorthand properties.
       */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROBitSet</span> <span class="variable-name" id="shorthandPropSet">shorthandPropSet</span>;
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">BitSet</span> <span class="variable-name" id="shorthandpropset">shorthandpropset</span>;
      <span class="jde-java-font-lock-modifier">static</span> {
          shorthandpropset = <span class="keyword">new</span> <span class="type">BitSet</span>(PropNames.<span class="jde-java-font-lock-constant" id="LAST_PROPERTY_INDEX">LAST_PROPERTY_INDEX</span> + <span class="jde-java-font-lock-number">1</span>);
          <span class="keyword">for</span> (<span class="type">int</span> <span class="variable-name">i</span> = <span class="jde-java-font-lock-number">0</span>; i &lt; shorthands.length; i++)
              shorthandpropset.set(shorthands[i]);
          shorthandPropSet = <span class="keyword">new</span> <span class="type">ROBitSet</span>(shorthandpropset);
      }
  
      <span class="comment">/**
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="property">property</span><span class="comment"> &lt;tt&gt;int&lt;/tt&gt; property index
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> &lt;tt&gt;ROIntArray&lt;/tt&gt; containing the expansion list for
       * this shorthand.
       * </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">&lt;tt&gt;PropertyException&lt;/tt&gt;</span><span class="comment"> if this is not a valid
       * shorthand property
       */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="type">ROIntArray</span> <span class="function-name" id="getSHandExpansionSet">getSHandExpansionSet</span>(<span class="type">int</span> <span class="variable-name">property</span>)
          <span class="keyword">throws</span> <span class="type">PropertyException</span>
      {
          <span class="comment">// Is the property of the argument a shorthand?
  </span>        <span class="type">Integer</span> <span class="variable-name" id="sHIndex">sHIndex</span> =
                  (<span class="type">Integer</span>)(shorthandMap.get(Ints.consts.get(property)));
          <span class="keyword">if</span> (sHIndex == <span class="jde-java-font-lock-constant" id="null">null</span>) {
              <span class="type">String</span> <span class="variable-name" id="propname">propname</span> = PropNames.getPropertyName(property);
              <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>
                      (propname + &quot;<span class="string"> not a shorthand property</span>&quot;);
          }
          <span class="comment">// Get the array of indices of the properties in the
  </span>        <span class="comment">// expansion of this shorthand
  </span>        <span class="keyword">return</span> shorthandExpansions[sHIndex.intValue()];
      }
  
      <span class="comment">/**
       * Expand the shorthand property associated with the
       * &lt;tt&gt;PropertyValue&lt;/tt&gt; argument by copying the given value for each
       * property in the expansion.  The &lt;em&gt;</span><span class="jde-java-font-lock-italic">property</span><span class="comment">&lt;/em&gt; field of each
       * &lt;tt&gt;PropertyValue&lt;/tt&gt; will be set to one of the proeprties in the
       * shorthand expansion.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="value">value</span><span class="comment"> a &lt;tt&gt;propertyValue&lt;/tt&gt; whose &lt;em&gt;</span><span class="jde-java-font-lock-italic">property</span><span class="comment">&lt;/em&gt; field
       *  is assumed to be set to a shorthand property.
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> &lt;tt&gt;PropertyValueList&lt;/tt&gt; containing a list of
       *  &lt;tt&gt;PropertyValue&lt;/tt&gt;s, one for each property in the expansion of
       *  the shorthand property.
       * </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">PropertyException
  </span><span class="comment">     */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="type">PropertyValueList</span> <span class="function-name" id="expandAndCopySHand">expandAndCopySHand</span>(<span class="type">PropertyValue</span> <span class="variable-name">value</span>)
          <span class="keyword">throws</span> <span class="type">PropertyException</span>
      {
          <span class="comment">// The property associated with this PropertyValue
  </span>        <span class="type">int</span> <span class="variable-name">property</span> = value.getProperty();
          <span class="type">ROIntArray</span> <span class="variable-name" id="expansion">expansion</span> = getSHandExpansionSet(property);
          <span class="type">PropertyValueList</span> <span class="variable-name" id="list">list</span> = <span class="keyword">new</span> <span class="type">PropertyValueList</span>(property);
          <span class="keyword">return</span> copyValueToSet(value, expansion, list);
      }
  
      <span class="comment">/**
       * Generate a list of the intial values of each property in a
       * shorthand expansion.  Note that this will be a list of
       * &lt;b&gt;</span><span class="jde-java-font-lock-bold">references</span><span class="comment">&lt;/b&gt; to the initial values.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="foTree">foTree</span><span class="comment"> the &lt;tt&gt;FOTree&lt;/tt&gt; for which properties are being
       * processed
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">property</span><span class="comment"> &lt;tt&gt;int&lt;/tt&gt; property index
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> &lt;tt&gt;PropertyValueList&lt;/tt&gt; containing the intial value
       * expansions for the (shorthand) property
       * </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">&lt;tt&gt;PropertyException&lt;/tt&gt;
  </span><span class="comment">     */</span>
       <span class="comment">/*
        Don't do this.  Shorthands should not expand initial values, because
        a distinction is needed between those properties which are given
        a specified value and those which are set by normal inheritance or from
        their initial values.  This so that fromSpecifiedValue() will work.
  
      public static PropertyValueList initialValueSHandExpansion
          (FOTree foTree, int property)
          throws PropertyException
      {
          ROIntArray expansion = getSHandExpansionSet(property);
          PropertyValueList list = new PropertyValueList(property);
          for (int i = 0; i &lt; expansion.length; i++) {
              int expandedProp = expansion.get(i);
              PropertyValue specified
                      = foTree.getInitialSpecifiedValue(expandedProp);
              list.add(specified);
          }
          return list;
      }
      */</span>
  
      <span class="comment">/**
       * Given a shorthand expansion list and a &lt;tt&gt;PropertyValue&lt;/tt&gt;,
       * override the list element corresponding to the &lt;tt&gt;PropertyValue&lt;/tt&gt;.
       * Correspondence is based on the &lt;em&gt;</span><span class="jde-java-font-lock-italic">property</span><span class="comment">&lt;/em&gt; field of the
       * &lt;tt&gt;PropertyValue&lt;/tt&gt;.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="expansionList">expansionList</span><span class="comment"> the expansion &lt;tt&gt;PropertyValueList&lt;/tt&gt;
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="element">element</span><span class="comment"> the overriding &lt;tt&gt;PropertyValue&lt;/tt&gt;
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> &lt;tt&gt;PropertyValueList&lt;/tt&gt; the expansion list with the
       *  appropriate element reset
       * </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">&lt;tt&gt;PropertyException&lt;/tt&gt;
  </span><span class="comment">     */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="type">PropertyValueList</span> <span class="variable-name" id="overrideSHandElement">overrideSHandElement</span>
          (<span class="type">PropertyValueList</span> <span class="variable-name">expansionList</span>, <span class="type">PropertyValue</span> <span class="variable-name">element</span>)
          <span class="keyword">throws</span> <span class="type">PropertyException</span>
      {
          <span class="type">int</span> <span class="variable-name" id="elementProp">elementProp</span> = element.getProperty();
          <span class="type">ListIterator</span> <span class="variable-name" id="elements">elements</span> = expansionList.listIterator();
          <span class="keyword">while</span> (elements.hasNext()) {
              <span class="type">PropertyValue</span> <span class="variable-name" id="next">next</span> = (<span class="type">PropertyValue</span>)(elements.next());
              <span class="keyword">if</span> (next.getProperty() == elementProp) {
                  elements.set(element);
                  <span class="keyword">return</span> expansionList;
              }
          }
          <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>
                  (&quot;<span class="string">Unmatched property </span>&quot; + elementProp +
                   &quot;<span class="string"> in expansion list for </span>&quot; + expansionList.getProperty());
      }
  
      <span class="comment">/**
       * Given a shorthand expansion list and a &lt;tt&gt;PropertyValueList&lt;/tt&gt;,
       * override the expansion list elements corresponding to the elements
       * of the &lt;tt&gt;PropertyValueList&lt;/tt&gt;.
       * Correspondence is based on the &lt;em&gt;</span><span class="jde-java-font-lock-italic">property</span><span class="comment">&lt;/em&gt; field of the
       * &lt;tt&gt;PropertyValue&lt;/tt&gt;.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">expansionList</span><span class="comment"> the expansion &lt;tt&gt;PropertyValueList&lt;/tt&gt;
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">list</span><span class="comment"> the overriding &lt;tt&gt;PropertyValueList&lt;/tt&gt;
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> &lt;tt&gt;PropertyValueList&lt;/tt&gt; the new expansion list with
       *  appropriate elements reset
       * </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">&lt;tt&gt;PropertyException&lt;/tt&gt;
  </span><span class="comment">     */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="type">PropertyValueList</span> <span class="variable-name" id="overrideSHandElements">overrideSHandElements</span>
          (<span class="type">PropertyValueList</span> <span class="variable-name">expansionList</span>, <span class="type">PropertyValueList</span> <span class="variable-name">list</span>)
          <span class="keyword">throws</span> <span class="type">PropertyException</span>
      {
          <span class="comment">// From the overriding list, form an array of PropertyValue references
  </span>        <span class="comment">// an array of property indices and an array of booleans,
  </span>        <span class="type">int</span> <span class="variable-name" id="listsize">listsize</span> = list.size();
          <span class="type">Object</span>[] <span class="variable-name" id="listrefs">listrefs</span> = <span class="keyword">new</span> <span class="type">Object</span>[listsize];
          <span class="type">int</span>[] <span class="variable-name" id="listprops">listprops</span> = <span class="keyword">new</span> <span class="type">int</span>[listsize];
          <span class="type">boolean</span>[] <span class="variable-name" id="propseen">propseen</span> = <span class="keyword">new</span> <span class="type">boolean</span>[listsize];
          <span class="type">Iterator</span> <span class="variable-name" id="listels">listels</span> = list.iterator();
          <span class="type">int</span> <span class="variable-name">i</span> = <span class="jde-java-font-lock-number">0</span>;
          <span class="keyword">while</span> (listels.hasNext()) {
              listrefs[i] = listels.next();
              listprops[i] = ((<span class="type">PropertyValue</span>)listrefs[i]).getProperty();
              i++;
          }
  
          <span class="type">ListIterator</span> <span class="variable-name">elements</span> = expansionList.listIterator();
          <span class="keyword">while</span> (elements.hasNext()) {
              <span class="type">PropertyValue</span> <span class="variable-name">next</span> = (<span class="type">PropertyValue</span>)(elements.next());
              <span class="type">int</span> <span class="variable-name" id="expprop">expprop</span> = next.getProperty();
              <span class="keyword">for</span> (i = <span class="jde-java-font-lock-number">0</span>; i &lt; listsize; i++) {
                  <span class="keyword">if</span> (expprop != listprops[i]) <span class="keyword">continue</span>;
                  elements.set(listrefs[i]);
                  propseen[i] = <span class="jde-java-font-lock-constant" id="true">true</span>;
              }
          }
          <span class="comment">// Check for unmatched override elements
  </span>        <span class="type">String</span> <span class="variable-name" id="unmatched">unmatched</span> = &quot;&quot;;
          <span class="type">boolean</span> <span class="variable-name" id="someunmatched">someunmatched</span> = <span class="jde-java-font-lock-constant" id="false">false</span>;
          <span class="keyword">for</span> (i = <span class="jde-java-font-lock-number">0</span>; i &lt; listsize; i++) {
              <span class="keyword">if</span> ( ! propseen[i]) {
                  someunmatched = <span class="jde-java-font-lock-constant">true</span>;
                  unmatched = unmatched + &quot;<span class="string"> </span>&quot; +
                          PropNames.getPropertyName(listprops[i]);
              }
          }
          <span class="keyword">if</span> (someunmatched)
              <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>
                  (&quot;<span class="string">Unmatched properties:</span>&quot; + unmatched +
                   &quot;<span class="string"> : in expansion list for </span>&quot; + expansionList.getProperty());
          <span class="keyword">return</span> expansionList;
      }
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="blockProgressionDimensionCopyExpansion">blockProgressionDimensionCopyExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(<span class="keyword">new</span> <span class="type">int</span>[] {
              <span class="reference">PropNames</span>.<span class="type">BLOCK_PROGRESSION_DIMENSION_MINIMUM</span>
              ,<span class="reference">PropNames</span>.<span class="type">BLOCK_PROGRESSION_DIMENSION_OPTIMUM</span>
              ,<span class="reference">PropNames</span>.<span class="type">BLOCK_PROGRESSION_DIMENSION_MAXIMUM</span>
          });
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="blockProgressionDimensionNonCopyExpansion">blockProgressionDimensionNonCopyExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(<span class="keyword">new</span> <span class="type">int</span>[] {});
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="borderAfterWidthCopyExpansion">borderAfterWidthCopyExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(<span class="keyword">new</span> <span class="type">int</span>[] {
              <span class="reference">PropNames</span>.<span class="type">BORDER_AFTER_WIDTH_LENGTH</span>
          });
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="borderAfterWidthNonCopyExpansion">borderAfterWidthNonCopyExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(<span class="keyword">new</span> <span class="type">int</span>[] {
              <span class="reference">PropNames</span>.<span class="type">BORDER_AFTER_WIDTH_CONDITIONALITY</span>
          });
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="borderBeforeWidthCopyExpansion">borderBeforeWidthCopyExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(<span class="keyword">new</span> <span class="type">int</span>[] {
              <span class="reference">PropNames</span>.<span class="type">BORDER_BEFORE_WIDTH_LENGTH</span>
          });
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="borderBeforeWidthNonCopyExpansion">borderBeforeWidthNonCopyExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(<span class="keyword">new</span> <span class="type">int</span>[] {
              <span class="reference">PropNames</span>.<span class="type">BORDER_BEFORE_WIDTH_CONDITIONALITY</span>
          });
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="borderEndWidthCopyExpansion">borderEndWidthCopyExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(<span class="keyword">new</span> <span class="type">int</span>[] {
              <span class="reference">PropNames</span>.<span class="type">BORDER_END_WIDTH_LENGTH</span>
          });
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="borderEndWidthNonCopyExpansion">borderEndWidthNonCopyExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(<span class="keyword">new</span> <span class="type">int</span>[] {
              <span class="reference">PropNames</span>.<span class="type">BORDER_END_WIDTH_CONDITIONALITY</span>
          });
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="borderStartWidthCopyExpansion">borderStartWidthCopyExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(<span class="keyword">new</span> <span class="type">int</span>[] {
              <span class="reference">PropNames</span>.<span class="type">BORDER_START_WIDTH_LENGTH</span>
          });
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="borderStartWidthNonCopyExpansion">borderStartWidthNonCopyExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(<span class="keyword">new</span> <span class="type">int</span>[] {
              <span class="reference">PropNames</span>.<span class="type">BORDER_START_WIDTH_CONDITIONALITY</span>
          });
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="borderSeparationCopyExpansion">borderSeparationCopyExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(<span class="keyword">new</span> <span class="type">int</span>[] {
              <span class="reference">PropNames</span>.<span class="type">BORDER_SEPARATION_BLOCK_PROGRESSION_DIRECTION</span>
              ,<span class="reference">PropNames</span>.<span class="type">BORDER_SEPARATION_INLINE_PROGRESSION_DIRECTION</span>
          });
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="borderSeparationNonCopyExpansion">borderSeparationNonCopyExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(<span class="keyword">new</span> <span class="type">int</span>[] {});
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="inlineProgressionDimensionCopyExpansion">inlineProgressionDimensionCopyExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(<span class="keyword">new</span> <span class="type">int</span>[] {
              <span class="reference">PropNames</span>.<span class="type">INLINE_PROGRESSION_DIMENSION_MINIMUM</span>
              ,<span class="reference">PropNames</span>.<span class="type">INLINE_PROGRESSION_DIMENSION_OPTIMUM</span>
              ,<span class="reference">PropNames</span>.<span class="type">INLINE_PROGRESSION_DIMENSION_MAXIMUM</span>
          });
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="inlineProgressionDimensionNonCopyExpansion">inlineProgressionDimensionNonCopyExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(<span class="keyword">new</span> <span class="type">int</span>[] {});
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="keepTogetherCopyExpansion">keepTogetherCopyExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(<span class="keyword">new</span> <span class="type">int</span>[] {
              <span class="reference">PropNames</span>.<span class="type">KEEP_TOGETHER_WITHIN_LINE</span>
              ,<span class="reference">PropNames</span>.<span class="type">KEEP_TOGETHER_WITHIN_COLUMN</span>
              ,<span class="reference">PropNames</span>.<span class="type">KEEP_TOGETHER_WITHIN_PAGE</span>
          });
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="keepTogetherNonCopyExpansion">keepTogetherNonCopyExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(<span class="keyword">new</span> <span class="type">int</span>[] {});
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="keepWithNextCopyExpansion">keepWithNextCopyExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(<span class="keyword">new</span> <span class="type">int</span>[] {
              <span class="reference">PropNames</span>.<span class="type">KEEP_WITH_NEXT_WITHIN_LINE</span>
              ,<span class="reference">PropNames</span>.<span class="type">KEEP_WITH_NEXT_WITHIN_COLUMN</span>
              ,<span class="reference">PropNames</span>.<span class="type">KEEP_WITH_NEXT_WITHIN_PAGE</span>
          });
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="keepWithNextNonCopyExpansion">keepWithNextNonCopyExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(<span class="keyword">new</span> <span class="type">int</span>[] {});
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="keepWithPreviousCopyExpansion">keepWithPreviousCopyExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(<span class="keyword">new</span> <span class="type">int</span>[] {
              <span class="reference">PropNames</span>.<span class="type">KEEP_WITH_PREVIOUS_WITHIN_LINE</span>
              ,<span class="reference">PropNames</span>.<span class="type">KEEP_WITH_PREVIOUS_WITHIN_COLUMN</span>
              ,<span class="reference">PropNames</span>.<span class="type">KEEP_WITH_PREVIOUS_WITHIN_PAGE</span>
          });
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="keepWithPreviousNonCopyExpansion">keepWithPreviousNonCopyExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(<span class="keyword">new</span> <span class="type">int</span>[] {});
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="leaderLengthCopyExpansion">leaderLengthCopyExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(<span class="keyword">new</span> <span class="type">int</span>[] {
              <span class="reference">PropNames</span>.<span class="type">LEADER_LENGTH_MINIMUM</span>
              ,<span class="reference">PropNames</span>.<span class="type">LEADER_LENGTH_OPTIMUM</span>
              ,<span class="reference">PropNames</span>.<span class="type">LEADER_LENGTH_MAXIMUM</span>
          });
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="leaderLengthNonCopyExpansion">leaderLengthNonCopyExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(<span class="keyword">new</span> <span class="type">int</span>[] {});
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="letterSpacingCopyExpansion">letterSpacingCopyExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(<span class="keyword">new</span> <span class="type">int</span>[] {
              <span class="reference">PropNames</span>.<span class="type">LETTER_SPACING_MINIMUM</span>
              ,<span class="reference">PropNames</span>.<span class="type">LETTER_SPACING_OPTIMUM</span>
              ,<span class="reference">PropNames</span>.<span class="type">LETTER_SPACING_MAXIMUM</span>
          });
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="letterSpacingNonCopyExpansion">letterSpacingNonCopyExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(<span class="keyword">new</span> <span class="type">int</span>[] {
              <span class="reference">PropNames</span>.<span class="type">LETTER_SPACING_CONDITIONALITY</span>
              ,<span class="reference">PropNames</span>.<span class="type">LETTER_SPACING_PRECEDENCE</span>
          });
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="lineHeightCopyExpansion">lineHeightCopyExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(<span class="keyword">new</span> <span class="type">int</span>[] {
              <span class="reference">PropNames</span>.<span class="type">LINE_HEIGHT_MINIMUM</span>
              ,<span class="reference">PropNames</span>.<span class="type">LINE_HEIGHT_OPTIMUM</span>
              ,<span class="reference">PropNames</span>.<span class="type">LINE_HEIGHT_MAXIMUM</span>
          });
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="lineHeightNonCopyExpansion">lineHeightNonCopyExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(<span class="keyword">new</span> <span class="type">int</span>[] {
              <span class="reference">PropNames</span>.<span class="type">LINE_HEIGHT_CONDITIONALITY</span>
              ,<span class="reference">PropNames</span>.<span class="type">LINE_HEIGHT_PRECEDENCE</span>
          });
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="paddingAfterCopyExpansion">paddingAfterCopyExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(<span class="keyword">new</span> <span class="type">int</span>[] {
              <span class="reference">PropNames</span>.<span class="type">PADDING_AFTER_LENGTH</span>
          });
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="paddingAfterNonCopyExpansion">paddingAfterNonCopyExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(<span class="keyword">new</span> <span class="type">int</span>[] {
              <span class="reference">PropNames</span>.<span class="type">PADDING_AFTER_CONDITIONALITY</span>
          });
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="paddingBeforeCopyExpansion">paddingBeforeCopyExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(<span class="keyword">new</span> <span class="type">int</span>[] {
              <span class="reference">PropNames</span>.<span class="type">PADDING_BEFORE_LENGTH</span>
          });
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="paddingBeforeNonCopyExpansion">paddingBeforeNonCopyExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(<span class="keyword">new</span> <span class="type">int</span>[] {
              <span class="reference">PropNames</span>.<span class="type">PADDING_BEFORE_CONDITIONALITY</span>
          });
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="paddingEndCopyExpansion">paddingEndCopyExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(<span class="keyword">new</span> <span class="type">int</span>[] {
              <span class="reference">PropNames</span>.<span class="type">PADDING_END_LENGTH</span>
          });
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="paddingEndNonCopyExpansion">paddingEndNonCopyExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(<span class="keyword">new</span> <span class="type">int</span>[] {
              <span class="reference">PropNames</span>.<span class="type">PADDING_END_CONDITIONALITY</span>
          });
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="paddingStartCopyExpansion">paddingStartCopyExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(<span class="keyword">new</span> <span class="type">int</span>[] {
              <span class="reference">PropNames</span>.<span class="type">PADDING_START_LENGTH</span>
          });
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="paddingStartNonCopyExpansion">paddingStartNonCopyExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(<span class="keyword">new</span> <span class="type">int</span>[] {
              <span class="reference">PropNames</span>.<span class="type">PADDING_START_CONDITIONALITY</span>
          });
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="spaceAfterCopyExpansion">spaceAfterCopyExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(<span class="keyword">new</span> <span class="type">int</span>[] {
              <span class="reference">PropNames</span>.<span class="type">SPACE_AFTER_MINIMUM</span>
              ,<span class="reference">PropNames</span>.<span class="type">SPACE_AFTER_OPTIMUM</span>
              ,<span class="reference">PropNames</span>.<span class="type">SPACE_AFTER_MAXIMUM</span>
          });
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="spaceAfterNonCopyExpansion">spaceAfterNonCopyExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(<span class="keyword">new</span> <span class="type">int</span>[] {
              <span class="reference">PropNames</span>.<span class="type">SPACE_AFTER_CONDITIONALITY</span>
              ,<span class="reference">PropNames</span>.<span class="type">SPACE_AFTER_PRECEDENCE</span>
          });
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="spaceBeforeCopyExpansion">spaceBeforeCopyExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(<span class="keyword">new</span> <span class="type">int</span>[] {
              <span class="reference">PropNames</span>.<span class="type">SPACE_BEFORE_MINIMUM</span>
              ,<span class="reference">PropNames</span>.<span class="type">SPACE_BEFORE_OPTIMUM</span>
              ,<span class="reference">PropNames</span>.<span class="type">SPACE_BEFORE_MAXIMUM</span>
          });
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="spaceBeforeNonCopyExpansion">spaceBeforeNonCopyExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(<span class="keyword">new</span> <span class="type">int</span>[] {
              <span class="reference">PropNames</span>.<span class="type">SPACE_BEFORE_CONDITIONALITY</span>
              ,<span class="reference">PropNames</span>.<span class="type">SPACE_BEFORE_PRECEDENCE</span>
          });
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="spaceEndCopyExpansion">spaceEndCopyExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(<span class="keyword">new</span> <span class="type">int</span>[] {
              <span class="reference">PropNames</span>.<span class="type">SPACE_END_MINIMUM</span>
              ,<span class="reference">PropNames</span>.<span class="type">SPACE_END_OPTIMUM</span>
              ,<span class="reference">PropNames</span>.<span class="type">SPACE_END_MAXIMUM</span>
          });
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="spaceEndNonCopyExpansion">spaceEndNonCopyExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(<span class="keyword">new</span> <span class="type">int</span>[] {
              <span class="reference">PropNames</span>.<span class="type">SPACE_END_CONDITIONALITY</span>
              ,<span class="reference">PropNames</span>.<span class="type">SPACE_END_PRECEDENCE</span>
          });
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="spaceStartCopyExpansion">spaceStartCopyExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(<span class="keyword">new</span> <span class="type">int</span>[] {
              <span class="reference">PropNames</span>.<span class="type">SPACE_START_MINIMUM</span>
              ,<span class="reference">PropNames</span>.<span class="type">SPACE_START_OPTIMUM</span>
              ,<span class="reference">PropNames</span>.<span class="type">SPACE_START_MAXIMUM</span>
          });
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="spaceStartNonCopyExpansion">spaceStartNonCopyExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(<span class="keyword">new</span> <span class="type">int</span>[] {
              <span class="reference">PropNames</span>.<span class="type">SPACE_START_CONDITIONALITY</span>
              ,<span class="reference">PropNames</span>.<span class="type">SPACE_START_PRECEDENCE</span>
          });
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="wordSpacingCopyExpansion">wordSpacingCopyExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(<span class="keyword">new</span> <span class="type">int</span>[] {
              <span class="reference">PropNames</span>.<span class="type">WORD_SPACING_MINIMUM</span>
              ,<span class="reference">PropNames</span>.<span class="type">WORD_SPACING_OPTIMUM</span>
              ,<span class="reference">PropNames</span>.<span class="type">WORD_SPACING_MAXIMUM</span>
          });
  
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="wordSpacingNonCopyExpansion">wordSpacingNonCopyExpansion</span> =
          <span class="keyword">new</span> <span class="type">ROIntArray</span>(<span class="keyword">new</span> <span class="type">int</span>[] {
              <span class="reference">PropNames</span>.<span class="type">WORD_SPACING_CONDITIONALITY</span>
              ,<span class="reference">PropNames</span>.<span class="type">WORD_SPACING_PRECEDENCE</span>
          });
  
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span>[] <span class="variable-name" id="compounds">compounds</span> = {
          <span class="reference">PropNames</span>.<span class="type">BLOCK_PROGRESSION_DIMENSION</span>
          ,<span class="reference">PropNames</span>.<span class="type">BORDER_AFTER_WIDTH</span>
          ,<span class="reference">PropNames</span>.<span class="type">BORDER_BEFORE_WIDTH</span>
          ,<span class="reference">PropNames</span>.<span class="type">BORDER_END_WIDTH</span>
          ,<span class="reference">PropNames</span>.<span class="type">BORDER_START_WIDTH</span>
          ,<span class="reference">PropNames</span>.<span class="type">BORDER_SEPARATION</span>
          ,<span class="reference">PropNames</span>.<span class="type">INLINE_PROGRESSION_DIMENSION</span>
          ,<span class="reference">PropNames</span>.<span class="type">KEEP_TOGETHER</span>
          ,<span class="reference">PropNames</span>.<span class="type">KEEP_WITH_NEXT</span>
          ,<span class="reference">PropNames</span>.<span class="type">KEEP_WITH_PREVIOUS</span>
          ,<span class="reference">PropNames</span>.<span class="type">LEADER_LENGTH</span>
          ,<span class="reference">PropNames</span>.<span class="type">LETTER_SPACING</span>
          ,<span class="reference">PropNames</span>.<span class="type">LINE_HEIGHT</span>
          ,<span class="reference">PropNames</span>.<span class="type">PADDING_AFTER</span>
          ,<span class="reference">PropNames</span>.<span class="type">PADDING_BEFORE</span>
          ,<span class="reference">PropNames</span>.<span class="type">PADDING_END</span>
          ,<span class="reference">PropNames</span>.<span class="type">PADDING_START</span>
          ,<span class="reference">PropNames</span>.<span class="type">SPACE_AFTER</span>
          ,<span class="reference">PropNames</span>.<span class="type">SPACE_BEFORE</span>
          ,<span class="reference">PropNames</span>.<span class="type">SPACE_END</span>
          ,<span class="reference">PropNames</span>.<span class="type">SPACE_START</span>
          ,<span class="reference">PropNames</span>.<span class="type">WORD_SPACING</span>
      };
  
      <span class="comment">/**
       * Map property index to compound array index
       */</span>
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">HashMap</span> <span class="variable-name" id="compoundMap">compoundMap</span>;
      <span class="jde-java-font-lock-modifier">static</span> {
          compoundMap = <span class="keyword">new</span> <span class="type">HashMap</span>(compounds.length);
          <span class="keyword">for</span> (<span class="type">int</span> <span class="variable-name">i</span> = <span class="jde-java-font-lock-number">0</span>; i &lt; compounds.length; i++) {
              compoundMap.put
                      ((<span class="type">Object</span>)(Ints.consts.get(compounds[i])), 
                       (<span class="type">Object</span>)(Ints.consts.get(i)));
          }
      }
  
      <span class="comment">/**
       * RO compound properties.
       */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span> <span class="variable-name" id="roCompounds">roCompounds</span>;
      <span class="jde-java-font-lock-modifier">static</span> {
          roCompounds = <span class="keyword">new</span> <span class="type">ROIntArray</span>(compounds);
      }
  
      <span class="comment">/**
       * A &lt;tt&gt;ROBitSet&lt;/tt&gt; of the compound properties.
       */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROBitSet</span> <span class="variable-name" id="compoundPropSet">compoundPropSet</span>;
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">BitSet</span> <span class="variable-name" id="compoundpropset">compoundpropset</span>;
  
      <span class="comment">/**
       * a &lt;tt&gt;ROBitSet of shorthand and compound properties.
       */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROBitSet</span> <span class="variable-name" id="shorthandCompoundProps">shorthandCompoundProps</span>;
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">BitSet</span> <span class="variable-name" id="shorthandcompoundprops">shorthandcompoundprops</span>;
  
      <span class="jde-java-font-lock-modifier">static</span> {
          compoundpropset = <span class="keyword">new</span> <span class="type">BitSet</span>(PropNames.<span class="jde-java-font-lock-constant">LAST_PROPERTY_INDEX</span> + <span class="jde-java-font-lock-number">1</span>);
          <span class="keyword">for</span> (<span class="type">int</span> <span class="variable-name">i</span> = <span class="jde-java-font-lock-number">0</span>; i &lt; compounds.length; i++)
              compoundpropset.set(compounds[i]);
          compoundPropSet = <span class="keyword">new</span> <span class="type">ROBitSet</span>(compoundpropset);
          shorthandcompoundprops = <span class="keyword">new</span> <span class="type">BitSet</span>();
          shorthandcompoundprops.or(compoundpropset);
          shorthandcompoundprops.or(shorthandpropset);
          shorthandCompoundProps = <span class="keyword">new</span> <span class="type">ROBitSet</span>(shorthandcompoundprops);
      }
  
      <span class="comment">/**
       * Array of &lt;i&gt;</span><span class="jde-java-font-lock-italic">ROIntArray</span><span class="comment">&lt;/i&gt;&lt;b&gt; of the copy expansion properties of
       * compounds in same order as &lt;i&gt;</span><span class="jde-java-font-lock-italic">compounds</span><span class="comment">&lt;/i&gt;&lt;/b&gt;
       * &lt;i&gt;</span><span class="jde-java-font-lock-italic">ROIntArray</span><span class="comment">&lt;/i&gt;.
       * If a public view of this is required, use
       * Collections.unmodifiableList(Arrays.asList(compoundCopyExpansions))
       */</span>
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span>[] <span class="variable-name" id="compoundCopyExpansions">compoundCopyExpansions</span> = {
          blockProgressionDimensionCopyExpansion
          ,borderAfterWidthCopyExpansion
          ,borderBeforeWidthCopyExpansion
          ,borderEndWidthCopyExpansion
          ,borderStartWidthCopyExpansion
          ,borderSeparationCopyExpansion
          ,inlineProgressionDimensionCopyExpansion
          ,keepTogetherCopyExpansion
          ,keepWithNextCopyExpansion
          ,keepWithPreviousCopyExpansion
          ,leaderLengthCopyExpansion
          ,letterSpacingCopyExpansion
          ,lineHeightCopyExpansion
          ,paddingAfterCopyExpansion
          ,paddingBeforeCopyExpansion
          ,paddingEndCopyExpansion
          ,paddingStartCopyExpansion
          ,spaceAfterCopyExpansion
          ,spaceBeforeCopyExpansion
          ,spaceEndCopyExpansion
          ,spaceStartCopyExpansion
          ,wordSpacingCopyExpansion
      };
  
      <span class="comment">/**
       * Array of &lt;i&gt;</span><span class="jde-java-font-lock-italic">ROIntArray</span><span class="comment">&lt;/i&gt;&lt;b&gt; of the non-copy expansion properties of
       * compounds in same order as &lt;i&gt;</span><span class="jde-java-font-lock-italic">compounds</span><span class="comment">&lt;/i&gt;&lt;/b&gt;
       * &lt;i&gt;</span><span class="jde-java-font-lock-italic">ROIntArray</span><span class="comment">&lt;/i&gt;.
       * If a public view of this is required, use
       * Collections.unmodifiableList(Arrays.asList(compoundNonCopyExpansions))
       */</span>
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">ROIntArray</span>[] <span class="variable-name" id="compoundNonCopyExpansions">compoundNonCopyExpansions</span> = {
          blockProgressionDimensionNonCopyExpansion
          ,borderAfterWidthNonCopyExpansion
          ,borderBeforeWidthNonCopyExpansion
          ,borderEndWidthNonCopyExpansion
          ,borderStartWidthNonCopyExpansion
          ,borderSeparationNonCopyExpansion
          ,inlineProgressionDimensionNonCopyExpansion
          ,keepTogetherNonCopyExpansion
          ,keepWithNextNonCopyExpansion
          ,keepWithPreviousNonCopyExpansion
          ,leaderLengthNonCopyExpansion
          ,letterSpacingNonCopyExpansion
          ,lineHeightNonCopyExpansion
          ,paddingAfterNonCopyExpansion
          ,paddingBeforeNonCopyExpansion
          ,paddingEndNonCopyExpansion
          ,paddingStartNonCopyExpansion
          ,spaceAfterNonCopyExpansion
          ,spaceBeforeNonCopyExpansion
          ,spaceEndNonCopyExpansion
          ,spaceStartNonCopyExpansion
          ,wordSpacingNonCopyExpansion
      };
  
      <span class="comment">/**
       * Expand the &lt;tt&gt;PropertyValue&lt;/tt&gt; assigned to a compound property
       * into &lt;tt&gt;propertyValues&lt;/tt&gt; for the individual property components.
       * N.B. This method assumes that the set of expansion properties is
       * comprised of a copy and a non-copy set.  For example, &amp;lt;space&amp;gt;
       * compounds have a copy set of .minimum, .optimum and .maximum, and a
       * non-copy set of .precedence and .conditionality. For each element of
       * the copy set, the given value is cloned.  For each member of the
       * non-copy set, a reference to the initial value is taken.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">foTree</span><span class="comment"> - the &lt;tt&gt;FOTree&lt;/tt&gt; for which properties are being
       * developed.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">value</span><span class="comment"> - the &lt;tt&gt;PropertyValue&lt;/tt&gt; to be cloned for the copy
       * set members.
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> a &lt;tt&gt;PropertyValueList&lt;/tt&gt; containing the copy set
       * expansions followed by the non-copy set expansions, in the order
       * they are defined in appropriate &lt;tt&gt;ROIntArray&lt;/tt&gt;s in this class.
       */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="type">PropertyValueList</span> <span class="variable-name" id="expandCompoundProperty">expandCompoundProperty</span>
                                          (<span class="type">FOTree</span> <span class="variable-name">foTree</span>, <span class="type">PropertyValue</span> <span class="variable-name">value</span>)
          <span class="keyword">throws</span> <span class="type">PropertyException</span>
      {
          <span class="type">int</span> <span class="variable-name">property</span> = value.getProperty();
          <span class="type">Integer</span> <span class="variable-name" id="compoundX">compoundX</span> =
                      (<span class="type">Integer</span>)(compoundMap.get(Ints.consts.get(property)));
          <span class="keyword">if</span> (compoundX == <span class="jde-java-font-lock-constant">null</span>)
              <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>
                  (PropNames.getPropertyName(property) + &quot;<span class="string"> (</span>&quot; + property + &quot;<span class="string">) </span>&quot;
                  + &quot;<span class="string"> is not a compound property.</span>&quot;);
          <span class="type">int</span> <span class="variable-name" id="compoundIdx">compoundIdx</span> = compoundX.intValue();
          <span class="type">PropertyValueList</span> <span class="variable-name">list</span> = <span class="keyword">new</span> <span class="type">PropertyValueList</span>(property);
          <span class="type">ROIntArray</span> <span class="variable-name">expansion</span>;
          <span class="comment">// Expand the copy components
  </span>        list = copyValueToSet
                          (value, compoundCopyExpansions[compoundIdx], list);
          <span class="comment">// Expand the non-copy components
  </span>        <span class="keyword">return</span> initialValueCompoundExpansion
                      (foTree, compoundNonCopyExpansions[compoundIdx], list);
      }
  
      <span class="comment">/**
       * Clone the given property value for each property in the given
       * expansion set.  Append the new property values to the given list.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">value</span><span class="comment"> - the property value to clone.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="expansionSet">expansionSet</span><span class="comment"> - the set of indices of the expansion properties.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">list</span><span class="comment"> - the list to which to append the expansion elements.
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> the original &lt;tt&gt;PropertyValueList&lt;/tt&gt; containing the
       * appended expansions.
       * </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">&lt;tt&gt;PropertyException&lt;/tt&gt;
  </span><span class="comment">     */</span>
      <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="type">PropertyValueList</span> <span class="function-name" id="copyValueToSet">copyValueToSet</span>(<span class="type">PropertyValue</span> <span class="variable-name">value</span>,
                              <span class="type">ROIntArray</span> <span class="variable-name">expansionSet</span>, <span class="type">PropertyValueList</span> <span class="variable-name">list</span>)
          <span class="keyword">throws</span> <span class="type">PropertyException</span>
      {
          <span class="keyword">for</span> (<span class="type">int</span> <span class="variable-name">i</span> = <span class="jde-java-font-lock-number">0</span>; i &lt; expansionSet.length; i++) {
              <span class="type">int</span> <span class="variable-name" id="expandedProp">expandedProp</span> = expansionSet.get(i);
              <span class="type">PropertyValue</span> <span class="variable-name" id="expandedPropValue">expandedPropValue</span>;
              <span class="comment">//   The PropertyValue must be cloneable
  </span>            <span class="comment">// The property associated with each PV in the expansion will
  </span>            <span class="comment">// necessarily be different.
  </span>            <span class="keyword">try</span> {
                  expandedPropValue = (<span class="type">PropertyValue</span>)(value.clone());
              } <span class="keyword">catch</span> (<span class="type">CloneNotSupportedException</span> <span class="variable-name" id="e">e</span>) {
                  <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(e.getMessage());
              }
  
              expandedPropValue.setProperty(expandedProp);
              list.add(expandedPropValue);
          }
          <span class="keyword">return</span> list;
      }
  
      <span class="comment">/**
       * Append the initial values of each non-copy property in a
       * compound expansion to a list.  Note that these elements will be
       * &lt;b&gt;</span><span class="jde-java-font-lock-bold">references</span><span class="comment">&lt;/b&gt; to the initial values. Note also that, in the
       * expansion of a compound value, the initial value comonents are
       * regarded as having been specified.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">foTree</span><span class="comment"> - the &lt;tt&gt;FOTree&lt;/tt&gt; of the node whose properties are
       * being processed.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">expansion</span><span class="comment"> - the set of indices of the expansion properties.
       * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">list</span><span class="comment"> - the list to which to append the expansion elements.
       * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> the original &lt;tt&gt;PropertyValueList&lt;/tt&gt; containing the
       * appended initial value expansions for the (compound) property.
       * </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">&lt;tt&gt;PropertyException&lt;/tt&gt;
  </span><span class="comment">     */</span>
      <span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="type">PropertyValueList</span> <span class="variable-name" id="initialValueCompoundExpansion">initialValueCompoundExpansion</span>
                  (<span class="type">FOTree</span> <span class="variable-name">foTree</span>, <span class="type">ROIntArray</span> <span class="variable-name">expansion</span>, <span class="type">PropertyValueList</span> <span class="variable-name">list</span>)
          <span class="keyword">throws</span> <span class="type">PropertyException</span>
      {
          <span class="keyword">for</span> (<span class="type">int</span> <span class="variable-name">i</span> = <span class="jde-java-font-lock-number">0</span>; i &lt; expansion.length; i++) {
              <span class="type">int</span> <span class="variable-name">expandedProp</span> = expansion.get(i);
              <span class="type">PropertyValue</span> <span class="variable-name" id="specified">specified</span>
                      = PropertyConsts.pconsts.getInitialValue(expandedProp);
              list.add(specified);
          }
          <span class="keyword">return</span> list;
      }
  
      <span class="jde-java-font-lock-modifier">private</span> <span class="function-name" id="ShorthandPropSets">ShorthandPropSets</span> (){}
  
  }
  </pre>
    </body>
  </html>
  
  
  
  1.1                  xml-site/targets/fop/design/alt.design/properties/simple-properties.html
  
  Index: simple-properties.html
  ===================================================================
  <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
  <html>
    <head>
      <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
      <title>Simple &lt;property&gt; Classes</title>
      <link type="text/css" href="../../../page.css" rel="stylesheet">
    </head>
    <body marginheight="0" marginwidth="0" topmargin="0" leftmargin="0" text="#000000" bgcolor="#FFFFFF">
      <div class="content">
        <h1>Simple &lt;property&gt; Classes</h1>
        <p>
          <font size="-2">by&nbsp;Peter B. West</font>
        </p>
        <ul class="minitoc">
          <li>
            <a href="#N10014">Introduction</a>
          </li>
          <li>
            <a href="#N10026">Common data</a>
          </li>
          <li>
            <a href="#N10075">Accessing &lt;property&gt; Data Constants</a>
          </li>
        </ul>
        
        <a name="N10014"></a>
        <h3>Introduction</h3>
        <p>
          An <a href="classes-overview.html">overview of the properties
          and classes</a> involved in handling properties has already
          been given.  This discussion will go in detail into the way
          data are represented within properties.  Iit is important to
          keep in mind that the primary avenue of access to the data and
          the methods of property classes is the <a href=
          "javascript:parent.displayCode(
          'PropertyConsts.html#PropertyConstsClass' )" ><span
          class="codefrag">PropertyConsts</span></a> class and its
          singleton object.
        </p>
        
        <a name="N10026"></a>
        <h3>Common data</h3>
        <p>
          
          <a href= "javascript:parent.displayCode( 'Character.html' )" ><span
          class="codefrag">org.apache.fop.fo.properties.Character</span></a>
          is an example of a basic property class.  The data fields
          common to all properties are:
        </p>
        <dl>
          
          <dt>
            
            <span class="codefrag">final int dataTypes</span>
            
          </dt>
          
          <dd>
            This field defines the allowable data types which may be
            assigned to the property.  The value is chosen from the data
            type constants defined in <a href=
            "javascript:parent.displayCode( 'Property.html#NOTYPE' )"
            ><span
            class="codefrag">org.apache.fop.fo.properties.Property</span></a>,
            and may consist of more than one of those constants,
            bit-ORed together.
          </dd>
          
          <dt>
            
            <span class="codefrag">final int traitMapping</span>
            
          </dt>
          
          <dd>
            This field defines the mapping of properties to traits in
            the <span class="codefrag">Area tree</span>. The value is
            chosen from the trait mapping constants defined in <a href=
            "javascript:parent.displayCode( 'Property.html#NO_TRAIT' )"
            ><span
            class="codefrag">org.apache.fop.fo.properties.Property</span></a>,
            and may consist of more than one of those constants,
            bit-ORed together.
          </dd>
          
          <dt>
            
            <span class="codefrag">final int initialValueType</span>
            
          </dt>
          
          <dd>
            This field defines the data type of the initial value
            assigned to the property.  The value is chosen from the
            initial value type constants defined in <a href=
            "javascript:parent.displayCode( 'Property.html#NOTYPE_IT' )"
            ><span
            class="codefrag">org.apache.fop.fo.properties.Property</span></a>.
            In the simplest property classes, such as <span
            class="codefrag">Character</span>, there is no defined
            initial value type.
          </dd>
          
          <dt>
            
            <span class="codefrag">final int inherited</span>
            
          </dt>
          
          <dd>
            This field defines the kind of inheritance applicable to the
            property.  The value is chosen from the inheritance
            constants defined in <a href=
            "javascript:parent.displayCode( 'Property.html#NO' )" ><span
            class="codefrag">org.apache.fop.fo.properties.Property</span></a>.
          </dd>
          
        </dl>
        
        <a name="N10075"></a>
        <h3>Accessing &lt;property&gt; Data Constants</h3>
        <p>
          The constants above are generally accessed through the arrays
          maintained in the <a href= "javascript:parent.displayCode(
          'PropertyConsts.html#PropertyConstsClass' )" ><span
          class="codefrag">PropertyConsts</span></a> singleton <a href=
          "javascript:parent.displayCode( 'PropertyConsts.html#pconsts'
          )" ><span class="codefrag">pconsts</span></a>.  The first
          invocation of the method <a href=
          "javascript:parent.displayCode(
          'PropertyConsts.html#setupProperty' )" ><span
          class="codefrag">setupProperty</span></a> on the property
          generates a <span class="codefrag">Class</span> instance for
          the class, and stores it in the array <a href=
          "javascript:parent.displayCode( 'PropertyConsts.html#classes'
          )" ><span class="codefrag">classes</span></a>.  This <span
          class="codefrag">Class</span> object is used, in turn, to
          instantiate the singleton instance of the class, which is
          stored in the <a href= "javascript:parent.displayCode(
          'PropertyConsts.html#properties' )" ><span
          class="codefrag">Property[] properties</span></a> array of <a
          href= "javascript:parent.displayCode(
          '../PropertyConsts.html#pconsts' )" ><span
          class="codefrag">pconsts</span></a>.
        </p>
        <p>
          
          <em>Reflection</em> methods are then used, via the same <span
          class="codefrag">Class</span> instance, to extract and store
          the static data fields.  These arrays and associated access
          methods are:
        </p>
        <dl>
          
          <dt>
            
            <a href= "javascript:parent.displayCode(
            'PropertyConsts.html#datatypes' )" ><span
            class="codefrag">int[] datatypes</span></a>
            
          </dt>
          
          <dd>
            
            <a href= "javascript:parent.displayCode(
            'PropertyConsts.html#getDataTypes' )" ><span
            class="codefrag">int getDataTypes(int)</span></a>
            
          </dd>
          
          <dt>
            
            <a href= "javascript:parent.displayCode(
            'PropertyConsts.html#traitMappings' )" ><span
            class="codefrag">int[] traitMappings</span></a>
            
          </dt>
          
          <dd>
            
            <em>No access method yet defined.</em>
            
          </dd>
          
          <dt>
            
            <a href= "javascript:parent.displayCode(
            'PropertyConsts.html#initialValueTypes' )" ><span
            class="codefrag">int[] initialValueTypes</span></a>
            
          </dt>
          
          <dd>
            
            <a href= "javascript:parent.displayCode(
            'PropertyConsts.html#getInitialValueType' )" ><span
            class="codefrag">int getInitialValueType(int)</span></a>
            
          </dd>
          
          <dt>
            
            <a href= "javascript:parent.displayCode(
            'PropertyConsts.html#inherited' )" ><span
            class="codefrag">int[] inherited</span></a>
            
          </dt>
          
          <dd>
            
            <a href= "javascript:parent.displayCode(
            'PropertyConsts.html#inheritance' )" ><span
            class="codefrag">int inheritance(int)</span></a>
            
          </dd>
          
        </dl>
  
        <p>
          <strong>Previous:</strong> <a href = "PropertyConsts-class.html"
          >PropertyConsts class</a>
        </p>
        <p>
          <strong>Next:</strong> <a href= "getInitialValue.html"
                                    >getInitialValue()</a>
        </p>
        
      </div>
      <table summary="footer" cellspacing="0" cellpadding="0" width="100%" height="20" border="0">
          <tr>
            <td colspan="2" height="1" bgcolor="#4C6C8F"><img height="1"
            width="1" alt="" src="../../../skin/images/spacer.gif"><a
            href="../../../skin/images/label.gif"></a><a
            href="../../../skin/images/page.gif"></a><a
            href="../../../skin/images/chapter.gif"></a><a
            href="../../../skin/images/chapter_open.gif"></a><a
            href="../../../skin/images/current.gif"></a><a
            href="../../..//favicon.ico"></a></td>
          </tr>
          <tr>
            <td colspan="2" bgcolor="#CFDCED" class="copyright"
            align="center"><font size="2" face="Arial, Helvetica,
            Sans-Serif">Copyright &copy; 1999-2002&nbsp;The Apache
            Software Foundation. All rights reserved.<script
            type="text/javascript" language="JavaScript"><!--
            document.write(" - "+"Last Published: " +
            document.lastModified); // --></script></font></td>
          </tr>
          <tr>
            <td align="left" bgcolor="#CFDCED" class="logos"></td><td
            align="right" bgcolor="#CFDCED" class="logos"></td>
          </tr>
      </table>
    </body>
  </html>
  
  
  

---------------------------------------------------------------------
To unsubscribe, e-mail: general-cvs-unsubscribe@xml.apache.org
For additional commands, e-mail: general-cvs-help@xml.apache.org


Mime
View raw message