mirrors
/
fop
mirror of https://github.com/apache/fop.git
Watch 1
Star 0
Fork 0
Code Issues 0 Releases 48 Wiki Activity
Browse Source

Code documentation 


git-svn-id: https://svn.apache.org/repos/asf/xmlgraphics/fop/trunk@195870 13f79535-47bb-0310-9956-ffa450edef68
pull/30/head
Peter Bernard West 21 years ago
parent
c6f80722d6
commit
807819bf42
19 changed files with 7442 additions and 0 deletions
Split View Show Diff Stats
  1. 119
    0
      src/documentation/content/design/alt.design/alt-design-frameset.html
  2. 14
    0
      src/documentation/content/design/alt.design/codeframe.html
  3. 103
    0
      src/documentation/content/design/alt.design/logo.html
  4. 231
    0
      src/documentation/content/design/alt.design/properties/AbstractPropertyValue.html
  5. 405
    0
      src/documentation/content/design/alt.design/properties/FOAttributes.html
  6. 867
    0
      src/documentation/content/design/alt.design/properties/PropNames.html
  7. 117
    0
      src/documentation/content/design/alt.design/properties/PropertyConsts-class.html
  8. 1038
    0
      src/documentation/content/design/alt.design/properties/PropertyParser.html
  9. 419
    0
      src/documentation/content/design/alt.design/properties/PropertySets.html
  10. 649
    0
      src/documentation/content/design/alt.design/properties/PropertyTokenizer.html
  11. 198
    0
      src/documentation/content/design/alt.design/properties/PropertyValue.html
  12. 352
    0
      src/documentation/content/design/alt.design/properties/PropertyValueList.html
  13. 1070
    0
      src/documentation/content/design/alt.design/properties/ShorthandPropSets.html
  14. 379
    0
      src/documentation/content/design/alt.design/properties/classes-overview.html
  15. 325
    0
      src/documentation/content/design/alt.design/properties/enumerated-values.html
  16. 174
    0
      src/documentation/content/design/alt.design/properties/getInitialValue.html
  17. 222
    0
      src/documentation/content/design/alt.design/properties/introduction.html
  18. 494
    0
      src/documentation/content/design/alt.design/properties/propertyExpressions.html
  19. 266
    0
      src/documentation/content/design/alt.design/properties/simple-properties.html

+ 119
- 0
src/documentation/content/design/alt.design/alt-design-frameset.html View File

@@ -0,0 +1,119 @@
<!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">
<style>
body {
font-family: Verdana, Helvetica, sans-serif;
}
frame.logo {align=right;}

.note { border: solid 1px #7099C5; background-color: #f0f0ff; }
.note .label { background-color: #7099C5; color: #ffffff; }
.content {
padding: 5px 5px 5px 10px;
font : Verdana, Helvetica, sans-serif; font-size : 90%;
}
</style>
<script type="application/x-javascript">
<!--
var isWide = false;
var isHigh = true;
function widenCol() {
if (isWide) { return; }
fset = document.getElementById("altDesignFramesetCols");
fset.setAttribute("cols", "60%,*");
logowin = top.frames[0];
logodoc = logowin.document;
wbutton = logodoc.getElementById("widenButton");
//tnode = document.createTextNode("<");
//tchild = wbutton.firstChild;
wbutton.setAttribute("value", "<");
isWide = true;
}
function narrowCol() {
if ( ! isWide) { return; }
fset = document.getElementById("altDesignFramesetCols");
fset.setAttribute("cols", "200,*");
logowin = top.frames[0];
logodoc = logowin.document;
wbutton = logodoc.getElementById("widenButton");
//tnode = document.createTextNode(">");
//tchild = wbutton.firstChild;
//wbutton.replaceChild(tnode, tchild);
wbutton.setAttribute("value", ">");
isWide = false;
}
function toggleColWidths() {
if (isWide) {
narrowCol();
} else {
widenCol()
}
}
function lengthenCol() {
if (isHigh) { return; }
fset = document.getElementById("altDesignFramesetRows");
fset.setAttribute("rows", "75%,*");
logowin = top.frames[0];
logodoc = logowin.document;
lbutton = logodoc.getElementById("lengthenButton");
//tnode = document.createTextNode("^");
//tchild = lbutton.firstChild;
//lbutton.replaceChild(tnode, tchild);
lbutton.setAttribute("value", "^");
isHigh = true;
}
function shortenCol() {
if ( ! isHigh) { return; }
fset = document.getElementById("altDesignFramesetRows");
fset.setAttribute("rows", "100,*");
logowin = top.frames[0];
logodoc = logowin.document;
lbutton = logodoc.getElementById("lengthenButton");
//tnode = document.createTextNode("v");
//tchild = lbutton.firstChild;
//lbutton.replaceChild(tnode, tchild);
lbutton.setAttribute("value", "v");
isHigh = false;
}
function toggleColHeights() {
if (isHigh) {
shortenCol();
} else {
lengthenCol()
}
}

function displayCode(src) {
top.frames[1].location = src;
widenCol();
shortenCol();
}

function displayHtml(src) {
top.frames[2].location = src;
narrowCol();
lengthenCol();
}
-->
</script>
</head>
<frameset id="altDesignFramesetCols" cols="200,*">
<frameset id="altDesignFramesetRows" rows="75%,*">
<frame id="logoFrame" class="logo" style="padding: 0px; margin: 0px:
border: 0px;" src="logo.html" scrolling="no">
<frame id= "codeDisplayFrame"
class= "codeDisplay"
src= "codeframe.html" >
</frameset>
<frame id="contents" src="properties/introduction.html">
</frameset>
</html>

+ 14
- 0
src/documentation/content/design/alt.design/codeframe.html View File

@@ -0,0 +1,14 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>Frame for Code Display</title>
<style type="text/css">
<!--
p { text-align:center }
-->
</style>
</head>
<body>
<p>Frame for code display.</p>
</body>
</html>

+ 103
- 0
src/documentation/content/design/alt.design/logo.html View File

@@ -0,0 +1,103 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>Logo for Properties</title>
<style type="text/css">
<!--
body {
font-family: Verdana, Helvetica, sans-serif;
background-image: url(../../images/logo.jpg);
background-position: top center;
background-repeat: no-repeat;
background-attachment: fixed;
background-color:#294563;border:0px;padding:0px:margin:0px
}
img {padding:0px;margin:0px;border:0px;}
input {float:right;}
input#widenButton {position:fixed; top: 0px; right: 0px}
input#lengthenButton {position:fixed; top: 2em; right: 0px}
li.toplevel {color: #CFDCED}
.menu {
margin: 0px; padding: 0px;
}
.menu a:link {color: white}
.menu a:visited {color: white}
.menu a:hover {color: #FFCC00}
.menu ul { margin: 0px 0px 0px 20px; padding: 0px; }
.content {
padding: 5px 5px 5px 10px;
font : small Verdana, Helvetica, sans-serif; font-size : 90%;
}
-->
</style>
</head>
<body>
<input id="widenButton" onclick="parent.toggleColWidths();return
true;" type="button" value="&gt;">
<input id="lengthenButton" onclick="parent.toggleColHeights();return
true;" type="button" value="^">
<div id="menu" class="menu">
<ul>
<li class="toplevel">Index
<ul>
<li>
<a href="../../index.html" target="_parent">FOP Home</a>
</li>
<li>
<a href="index.html" target="_parent">Alt Design</a>
</li>
</ul>
</li>
<li class="toplevel">Alt Design Properties</font>
<ul>
<li>
<a href= "javascript:parent.displayHtml(
'properties/introduction.html' )" >Introduction</a>
</li>
<li>
<a href= "javascript:parent.displayHtml(
'properties/classes-overview.html' )" >Classes
overview</a>
</li>
<li>
<a href= "javascript:parent.displayHtml(
'properties/PropertyConsts-class.html' )"
>PropertyConsts</a>
</li>
<li>
<a href= "javascript:parent.displayHtml(
'properties/simple-properties.html' )" >Simple
Properties</a>
</li>
<li>
<a href= "javascript:parent.displayHtml(
'properties/getInitialValue.html' )"
>getInitialValue</a>
</li>
<li>
<a href= "javascript:parent.displayHtml(
'properties/enumerated-values.html' )" >Enumerated
data</a>
</li>
<li>
<a href= "javascript:parent.displayHtml(
'properties/propertyExpressions.html' )" >Property
parsing</a>
</li>
</ul>
</li>
</ul>
</div>
</body>
</html>

+ 231
- 0
src/documentation/content/design/alt.design/properties/AbstractPropertyValue.html View File

@@ -0,0 +1,231 @@
<!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$
*
* 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$ $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>

+ 405
- 0
src/documentation/content/design/alt.design/properties/FOAttributes.html View File

@@ -0,0 +1,405 @@
<!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$
*
* 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$ $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$</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>

+ 867
- 0
src/documentation/content/design/alt.design/properties/PropNames.html View File

@@ -0,0 +1,867 @@
<!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$
* 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$ $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$</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>

+ 117
- 0
src/documentation/content/design/alt.design/properties/PropertyConsts-class.html View File

@@ -0,0 +1,117 @@
<!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>
<style type= "text/css" >
span.codeDisplay {font:italic bold}
body {
font-family: Verdana, Helvetica, sans-serif;
}

.note { border: solid 1px #7099C5; background-color: #f0f0ff; }
.note .label { background-color: #7099C5; color: #ffffff; }
.content {
padding: 5px 5px 5px 10px;
font : Verdana, Helvetica, sans-serif; font-size : 90%;
}
</style>
</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>

+ 1038
- 0
src/documentation/content/design/alt.design/properties/PropertyParser.html
File diff suppressed because it is too large
View File


+ 419
- 0
src/documentation/content/design/alt.design/properties/PropertySets.html View File

@@ -0,0 +1,419 @@
<!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$
* &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$ $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$</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>

+ 649
- 0
src/documentation/content/design/alt.design/properties/PropertyTokenizer.html View File

@@ -0,0 +1,649 @@
<!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$
* 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$</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>

+ 198
- 0
src/documentation/content/design/alt.design/properties/PropertyValue.html View File

@@ -0,0 +1,198 @@
<!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$
*
* 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$ $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>

+ 352
- 0
src/documentation/content/design/alt.design/properties/PropertyValueList.html View File

@@ -0,0 +1,352 @@
<!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$
*
* 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$ $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>

+ 1070
- 0
src/documentation/content/design/alt.design/properties/ShorthandPropSets.html
File diff suppressed because it is too large
View File


+ 379
- 0
src/documentation/content/design/alt.design/properties/classes-overview.html View File

@@ -0,0 +1,379 @@
<!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>
<style type= "text/css" >
body {
font-family: Verdana, Helvetica, sans-serif;
}
.note { border: solid 1px #7099C5; background-color: #f0f0ff; }
.note .label { background-color: #7099C5; color: #ffffff; }
.content {
padding: 5px 5px 5px 10px;
font : Verdana, Helvetica, sans-serif; font-size : 90%;
}
</style>
</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>

+ 325
- 0
src/documentation/content/design/alt.design/properties/enumerated-values.html View File

@@ -0,0 +1,325 @@
<!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>
<style type= "text/css" >
body {
font-family: Verdana, Helvetica, sans-serif;
}

.note { border: solid 1px #7099C5; background-color: #f0f0ff; }
.note .label { background-color: #7099C5; color: #ffffff; }
.content {
padding: 5px 5px 5px 10px;
font : Verdana, Helvetica, sans-serif; font-size : 90%;
}
</style>
</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>

+ 174
- 0
src/documentation/content/design/alt.design/properties/getInitialValue.html View File

@@ -0,0 +1,174 @@
<!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>
<style type= "text/css" >
span.codeDisplay {font:italic bold}
body {
font-family: Verdana, Helvetica, sans-serif;
}

.note { border: solid 1px #7099C5; background-color: #f0f0ff; }
.note .label { background-color: #7099C5; color: #ffffff; }
.content {
padding: 5px 5px 5px 10px;
font : Verdana, Helvetica, sans-serif; font-size : 90%;
}
</style>
</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>

+ 222
- 0
src/documentation/content/design/alt.design/properties/introduction.html View File

@@ -0,0 +1,222 @@
<!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>
<style type= "text/css" >
body {
font-family: Verdana, Helvetica, sans-serif;
}

.note { border: solid 1px #7099C5; background-color: #f0f0ff; }
.note .label { background-color: #7099C5; color: #ffffff; }
.content {
padding: 5px 5px 5px 10px;
font : Verdana, Helvetica, sans-serif; font-size : 90%;
}
</style>
</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>

+ 494
- 0
src/documentation/content/design/alt.design/properties/propertyExpressions.html View File

@@ -0,0 +1,494 @@
<!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>
<style type= "text/css" >
body {
font-family: Verdana, Helvetica, sans-serif;
}

.note { border: solid 1px #7099C5; background-color: #f0f0ff; }
.note .label { background-color: #7099C5; color: #ffffff; }
.content {
padding: 5px 5px 5px 10px;
font : Verdana, Helvetica, sans-serif; font-size : 90%;
}
</style>
</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">MappedEnumType</th>
<td colspan="2" rowspan="1">
A subclass of <em>EnumType</em>. Maintains a
<em>String</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>String</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>
The tokenizer returns one of the following token
values:
</p>
<pre class="code">
static final int
EOF = 0
,NCNAME = 1
,MULTIPLY = 2
,LPAR = 3
,RPAR = 4
,LITERAL = 5
,FUNCTION_LPAR = 6
,PLUS = 7
,MINUS = 8
,MOD = 9
,DIV = 10
,COMMA = 11
,PERCENT = 12
,COLORSPEC = 13
,FLOAT = 14
,INTEGER = 15
,ABSOLUTE_LENGTH = 16
,RELATIVE_LENGTH = 17
,TIME = 18
,FREQ = 19
,ANGLE = 20
,INHERIT = 21
,AUTO = 22
,NONE = 23
,BOOL = 24
,URI = 25
,MIMETYPE = 26
// NO_UNIT is a transient token for internal use only. It is
// never set as the end result of parsing a token.
,NO_UNIT = 27
;
</pre>
<p>
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 <span
class="codefrag">PropertyValueList</span>, necessary because
of the possibility that a list of <span
class="codefrag">PropertyValue</span> 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 for the peculiar case of of
<em>text-shadow</em>, which 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>

+ 266
- 0
src/documentation/content/design/alt.design/properties/simple-properties.html View File

@@ -0,0 +1,266 @@
<!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>
<style type= "text/css" >
body {
font-family: Verdana, Helvetica, sans-serif;
}

.note { border: solid 1px #7099C5; background-color: #f0f0ff; }
.note .label { background-color: #7099C5; color: #ffffff; }
.content {
padding: 5px 5px 5px 10px;
font : Verdana, Helvetica, sans-serif; font-size : 90%;
}
</style>
</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>

Write Preview
Loading…
Cancel
Save