<META http-equiv= "Content-Type" content= "text/html;
charset=ISO-8859-1" />
<title>Property classes overview</title>
- <script type="text/javascript" src="scripts/codedisplay.js">
- </script>
</head>
<body marginheight= "0" marginwidth= "0" topmargin= "0" leftmargin= "0" text= "#000000" bgcolor= "#FFFFFF" >
+ <script type="text/javascript" src="codedisplay.js" />
<div class= "content" >
<h1>Property classes overview</h1>
<p>
</ul>
</li>
</ul>
- <a name= "N10014" ></a> <h3>Properties: packages</h3> <a name=
- "N10019" ></a> <h4>org.apache.fop.fo</h4>
+ <a name= "N10014" ></a> <h3>Properties: packages</h3>
+ <a name= "N10019" ></a> <h4>org.apache.fop.fo</h4>
+ <!-- N.B. height for toggleCode changed from 50% to 400 because
+ Mozilla seems to get confused by percentage heights within
+ table elements.
+ -->
<dl>
<dt>
<span id="span00" ></span>
<a href = "javascript:toggleCode('span00',
- 'PropNames.html#PropNamesClass', '50%', '100%'
+ 'PropNames.html#PropNamesClass', '400', '100%'
)" ><em>PropNames</em></a>
</dt>
<dd>
This class maintains an array of <span id="span01"
></span><a href= "javascript:toggleCode( 'span01',
- 'PropNames.html#propertyNames', '50%', '100%' )" >property
+ 'PropNames.html#propertyNames', '400', '100%' )" >property
names</a>, synchronized to a complete set of property name
<span id="span02" ></span><a href = "javascript:toggleCode(
- 'span02', 'PropNames.html#NO_PROPERTY', '50%', '100%' )"
+ 'span02', 'PropNames.html#NO_PROPERTY', '400', '100%' )"
>constants</a> for indexing property-based arrays. It
includes methods to <span id="span03" ></span><a href =
"javascript:toggleCode( 'span03',
- 'PropNames.html#getPropertyName', '50%', '100%' )" >convert
+ 'PropNames.html#getPropertyName', '400', '100%' )" >convert
an index to a name</a> and to <span id="span04" ></span><a
href = "javascript:toggleCode( 'span04',
- 'PropNames.html#getPropertyIndex', '50%', '100%' )" >convert
+ 'PropNames.html#getPropertyIndex', '400', '100%' )" >convert
a property name to an index</a>.
</dd>
<dt>
>PropertyConsts</span> is created by the static initializer
of the <span id="span05" ></span><a href =
"javascript:toggleCode( 'span05',
- 'PropertyConsts.html#pconsts', '50%', '100%' )" >pconsts</a>
+ 'PropertyConsts.html#pconsts', '400', '100%' )" >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 <span
id="span06" ></span><a href = "javascript:toggleCode(
- 'span06', 'PropertyConsts.html#setupProperty', '50%', '100%'
+ 'span06', 'PropertyConsts.html#setupProperty', '400', '100%'
)" >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
</dd>
<dt>
<span id="span07" ></span><a href = "javascript:toggleCode(
- 'span07', 'PropertySets.html#PropertySetsClass', '50%',
+ 'span07', 'PropertySets.html#PropertySetsClass', '400',
'100%' )" ><em>PropertySets</em></a>
</dt>
<dd>
properties defined in <em>Section 7</em> of the
specification. Note that the <span id="span08" ></span
><a href= "javascript:toggleCode( 'span08',
- 'PropertySets.html#borderProps', '50%', '100%' )"
+ 'PropertySets.html#borderProps', '400', '100%' )"
><em>Border</em></a>, <span id="span09" ></span ><a href=
"javascript:toggleCode( 'span09',
- 'PropertySets.html#paddingProps', '50%', '100%' )"
+ 'PropertySets.html#paddingProps', '400', '100%' )"
><em>Padding</em></a> and <span id="span10" ></span><a
href= "javascript:toggleCode( 'span10',
- 'PropertySets.html#backgroundProps', '50%', '100%'
+ 'PropertySets.html#backgroundProps', '400', '100%'
)"><em>Background</em></a> sets are defined separately.
</dd>
<dt>
<span id="span11" ></span><a href = "javascript:toggleCode(
'span11', '../FOPropertySets.html#FOPropertySetsClass',
- '50%', '100%' )"><em>FOPropertySets</em></a>
+ '400', '100%' )"><em>FOPropertySets</em></a>
</dt>
<dd>
This class provides a number of <span class= "codefrag"
<dt>
<span id="span12" ></span><a href = "javascript:toggleCode(
'span12', 'ShorthandPropSets.html#ShorthandPropSetsClass',
- '50%', '100%' )"><em>ShorthandPropSets</em></a>
+ '400', '100%' )"><em>ShorthandPropSets</em></a>
</dt>
<dd>
This class contains arrays of <span id="span13" ></span><a
href = "javascript:toggleCode( 'span13',
- 'ShorthandPropSets.html#shorthands', '50%', '100%' )"
+ 'ShorthandPropSets.html#shorthands', '400', '100%' )"
>shorthand property indices</a> and <span id="span14"
></span><a href = "javascript:toggleCode( 'span14',
- 'ShorthandPropSets.html#compounds', '50%', '100%' )"
+ 'ShorthandPropSets.html#compounds', '400', '100%' )"
>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
</dd>
<dt>
<span id="span15" ></span><a href = "javascript:toggleCode(
- 'span15', 'FOAttributes.html#FOAttributesClass', '50%',
+ 'span15', 'FOAttributes.html#FOAttributesClass', '400',
'100%' )"><em>FOAttributes</em></a>
</dt>
<dd>
a SAX <span class= "codefrag" >startElement</span> event.
<em>fo:</em> namespace attributes are entered into a <span
id = "span16" ></span ><a href = "javascript:toggleCode(
- 'span16', 'FOAttributes.html#foAttrMap', '50%', '100%' )"
+ 'span16', 'FOAttributes.html#foAttrMap', '400', '100%' )"
><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
<span id="span17" ></span><a href = "javascript:toggleCode(
- 'span17', 'FOAttributes.html#nSpaceAttrMaps', '50%', '100%'
+ 'span17', 'FOAttributes.html#nSpaceAttrMaps', '400', '100%'
)"><span class= "codefrag" >HashMap</span>s</a>, indexed by
the <em>local name</em> of the attribute.
</dd>
<dl>
<dt>
<span id="span18" ></span><a href="javascript:toggleCode(
- 'span18', 'Property.html#PropertyClass', '50%', '100%' )"
+ 'span18', 'Property.html#PropertyClass', '400', '100%' )"
><em>Property</em></a>
</dt>
<dd>
<dt>
<span id="span19" ></span><a href = "javascript:toggleCode(
'span19', 'PropertyTokenizer.html#PropertyTokenizerClass',
- '50%', '100%' )"><em>PropertyTokenizer</em></a>
+ '400', '100%' )"><em>PropertyTokenizer</em></a>
</dt>
<dd>
The tokenizer for the property expression parser. Defines a
set of <span id="span20" ></span><a href =
"javascript:toggleCode( 'span20',
- 'PropertyTokenizer.html#EOF', '50%', '100%' )" >token
+ 'PropertyTokenizer.html#EOF', '400', '100%' )" >token
constants</a> and returns these with associated token
values.
</dd>
<dt>
<span id="span21" ></span><a href = "javascript:toggleCode(
- 'span21', 'PropertyParser.html#PropertyParserClass', '50%',
+ 'span21', 'PropertyParser.html#PropertyParserClass', '400',
'100%' )"><em>PropertyParser</em></a>
</dt>
<dd>
<dt>
<span id="span22" ></span><a href = "javascript:toggleCode(
'span22', 'PropertyValue.html#PropertyValueInterface',
- '50%', '100%' )"><em>PropertyValue</em></a>
+ '400', '100%' )"><em>PropertyValue</em></a>
</dt>
<dd>
An <em>interface</em> which all <span class= "codefrag"
to a few methods, <span class= "codefrag"
>PropertyValue</span> defines the set of <span id="span23"
></span><a href = "javascript:toggleCode( 'span23',
- 'PropertyValue.html#NO_TYPE', '50%', '100%' )"
+ 'PropertyValue.html#NO_TYPE', '400', '100%' )"
>constants</a> which the <span class= "codefrag"
>getType()</span> method may return; i.e. the valid set of
<span class= "codefrag" >PropertyValue</span> types.
<span id="span24" ></span><a href = "javascript:toggleCode(
'span24',
'AbstractPropertyValue.html#AbstractPropertyValueClass',
- '50%', '100%' )"><em>AbstractPropertyValue</em></a>
+ '400', '100%' )"><em>AbstractPropertyValue</em></a>
</dt>
<dd>
An abstract implementation of the <span class= "codefrag"
<dt>
<span id="span25" ></span><a href = "javascript:toggleCode(
'span25', 'PropertyValueList.html#PropertyValueListClass',
- '50%', '100%' )"><em>PropertyValueList</em></a>
+ '400', '100%' )"><em>PropertyValueList</em></a>
</dt>
<dd>
This class extends <span class= "codefrag"
<META http-equiv="Content-Type" content="text/html;
charset=ISO-8859-1" />
<title>Enumerated Data Values</title>
- <script type="text/javascript" src="scripts/codedisplay.js">
- </script>
</head>
<body marginheight="0" marginwidth="0" topmargin="0" leftmargin="0" text="#000000" bgcolor="#FFFFFF">
+ <script type="text/javascript" src="codedisplay.js" />
<div class="content">
<h1>Enumerated Data Values</h1>
<ul class="minitoc">
</p>
<a name="N10020"></a>
<h4>Array representation</h4>
+ <!-- N.B. height for toggleCode changed from 50% to 400 because
+ Mozilla seems to get confused by percentage heights within
+ table elements.
+ -->
<p>
<span id = "span00" ></span ><a href= "javascript:toggleCode(
- 'span00', 'Direction.html#DirectionClass', '50%', '100%' )"
+ 'span00', 'Direction.html#DirectionClass', '400', '100%' )"
><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 <span id = "span01" ></span
><a href= "javascript:toggleCode( 'span01',
- 'Direction.html#dataTypes', '50%', '100%' )" ><span
+ 'Direction.html#dataTypes', '400', '100%' )" ><span
class="codefrag">dataTypes</span></a> field contains the <span
id = "span02" ></span ><a href= "javascript:toggleCode(
- 'span02', 'Property.html#NOTYPE', '50%', '100%' )" ><span
+ 'span02', 'Property.html#NOTYPE', '400', '100%' )" ><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, <span id = "span03" ></span
><a href= "javascript:toggleCode( 'span03',
- 'Direction.html#LTR', '50%', '100%') "><span class="codefrag'
+ 'Direction.html#LTR', '400', '100%') "><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=
The publicly accessible mapping from enumeration token to
enumeration constant is achieved through the method <span id =
"span04" ></span ><a href= "javascript:toggleCode( 'span04',
- 'Direction.html#getEnumIndex', '50%', '100%' )" ><span
+ 'Direction.html#getEnumIndex', '400', '100%' )" ><span
class="codefrag">int getEnumIndex(String)</span></a>. The
corresponding mapping from enumeration constant to enumeration
token is achieved through the method <span id = "span05"
></span ><a href= "javascript:toggleCode( 'span05',
- 'Direction.html#getEnumText', '50%', '100%' )" ><span
+ 'Direction.html#getEnumText', '400', '100%' )" ><span
class="codefrag">String getEnumText(int)</span></a>.
</p>
<a name="N1005C"></a>
<p>
<span id = "span06" ></span ><a href= "javascript:toggleCode(
- 'span06', 'RenderingIntent.html#RenderingIntentClass', '50%',
+ 'span06', 'RenderingIntent.html#RenderingIntentClass', '400',
'100%' )" ><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 <span id = "span07" ></span ><a
href= "javascript:toggleCode( 'span07',
- 'RenderingIntent.html#dataTypes', '50%', '100%' )" ><span
+ 'RenderingIntent.html#dataTypes', '400', '100%' )" ><span
class="codefrag">dataTypes</span></a> field contains the <span
id = "span08" ></span ><a href= "javascript:toggleCode(
- 'span08', 'Property.html#NOTYPE', '50%', '100%' )" ><span
+ 'span08', 'Property.html#NOTYPE', '400', '100%' )" ><span
class="codefrag">ENUM</span> data type constant, defined in
<span class="codefrag">Property</span></a>. Enumeration
integer constants are defined as <span id = "span09" ></span
><a href= "javascript:toggleCode( 'span09',
- 'RenderingIntent.html#PERCEPTUAL', '50%', '100%' )" ><span
+ 'RenderingIntent.html#PERCEPTUAL', '400', '100%' )" ><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 <span id =
"span10" ></span ><a href= "javascript:toggleCode( 'span10',
- 'RenderingIntent.html#rwEnums', '50%', '100%' )" ><span
+ 'RenderingIntent.html#rwEnums', '400', '100%' )" ><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> <span id = "span11"
></span ><a href= "javascript:toggleCode( 'span11',
'RenderingIntent.html#rwEnumHash"><span class="codefrag',
- '50%', '100%' )" > rwEnumHash</span></a>, which is initialized
+ '400', '100%' )" > 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>
The publicly accessible mapping from enumeration token to
enumeration constant is achieved through the method <span id =
"span12" ></span ><a href= "javascript:toggleCode( 'span12',
- 'RenderingIntent.html#getEnumIndex', '50%', '100%' )" ><span
+ 'RenderingIntent.html#getEnumIndex', '400', '100%' )" ><span
class="codefrag">int getEnumIndex(String)</span></a>. The
corresponding mapping from enumeration constant to enumeration
token is achieved through the method <span id = "span13"
></span ><a href= "javascript:toggleCode( 'span13',
- 'RenderingIntent.html#getEnumText', '50%', '100%' )" ><span
+ 'RenderingIntent.html#getEnumText', '400', '100%' )" ><span
class="codefrag">String getEnumText(int)</span></a>.
</p>
<a name="N1009D"></a>
out to a new class, which each of the properties then extends.
An example of such a common super-class is <span id = "span14"
></span ><a href= "javascript:toggleCode( 'span14',
- 'BorderCommonStyle.html#BorderCommonStyleClass', '50%', '100%'
+ 'BorderCommonStyle.html#BorderCommonStyleClass', '400', '100%'
)" ><span class="codefrag">BorderCommonStyle</span></a>. Like
a property with a normal HashMap representation of an
enumerated value, BorderCommonStyle defines <span id =
"span15" ></span ><a href= "javascript:toggleCode( 'span15',
- 'BorderCommonStyle.html#HIDDEN', '50%', '100%' )" ><span
+ 'BorderCommonStyle.html#HIDDEN', '400', '100%' )" ><span
class="codefrag">public static final int</span></a>
enumeration integer constants. Similarly, the enumeration
tokens are stored in the array <span id = "span16" ></span ><a
href= "javascript:toggleCode( 'span16',
- 'BorderCommonStyle.html#rwEnums', '50%', '100%' )" ><span
+ 'BorderCommonStyle.html#rwEnums', '400', '100%' )" ><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> <span id =
"span17" ></span ><a href= "javascript:toggleCode( 'span17',
- 'BorderCommonStyle.html#rwEnumHash', '50%', '100%' )" ><span
+ 'BorderCommonStyle.html#rwEnumHash', '400', '100%' )" ><span
class="codefrag"> rwEnumHash</span></a>, initialized in a
<span class="codefrag">static {}</span> initializer. The
mapping methods <span id = "span18" ></span ><a href=
"javascript:toggleCode( 'span18',
- 'BorderCommonStyle.html#getEnumIndex', '50%', '100%' )" ><span
+ 'BorderCommonStyle.html#getEnumIndex', '400', '100%' )" ><span
class="codefrag">int getEnumIndex(String)</span></a> and <span
id = "span19" ></span ><a href= "javascript:toggleCode(
- 'span19', 'BorderCommonStyle.html#getEnumText', '50%', '100%'
+ 'span19', 'BorderCommonStyle.html#getEnumText', '400', '100%'
)" ><span class="codefrag">String getEnumText(int)</span></a>
are also present.
</p>
values are defined in the individual sub-classes of this
class, e.g. <span id = "span20" ></span ><a href=
"javascript:toggleCode( 'span20',
- 'BorderLeftStyle.html#BorderLeftStyleClass', '50%', '100%' )"
+ 'BorderLeftStyle.html#BorderLeftStyleClass', '400', '100%' )"
><span class="codefrag">BorderLeftStyle</span></a>. None of
the above fields or methods occur, and <span
class="codefrag">BorderLeftStyle</span> is left looking like
<p>
An example is the <span id = "span21" ></span ><a href=
"javascript:toggleCode( 'span21',
- 'BorderCommonWidth.html#BorderCommonWidthClass', '50%', '100%'
+ 'BorderCommonWidth.html#BorderCommonWidthClass', '400', '100%'
)" ><span class="codefrag">BorderCommonWidth</span></a>
property. This, like the example of <a
href="#common-enum-values"><span
class="codefrag">BorderCommonWidth</span>, therefore, also
defines <span id = "span22" ></span ><a href=
"javascript:toggleCode( 'span22',
- 'BorderCommonWidth.html#THIN', '50%', '100%' )" ><span
+ 'BorderCommonWidth.html#THIN', '400', '100%' )" ><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 <span id = "span23" ></span
><a href= "javascript:toggleCode( 'span23',
- 'BorderCommonWidth.html#getEnumIndex', '50%', '100%' )" ><span
+ 'BorderCommonWidth.html#getEnumIndex', '400', '100%' )" ><span
class="codefrag">int getEnumIndex(String)</span></a> and <span
id = "span24" ></span ><a href= "javascript:toggleCode(
- 'span24', 'BorderCommonWidth.html#getEnumText', '50%', '100%'
+ 'span24', 'BorderCommonWidth.html#getEnumText', '400', '100%'
)" ><span class="codefrag">String getEnumText(int)</span></a>
are present.
</p>
<p>
The added element in this property is the array <span id =
"span25" ></span ><a href= "javascript:toggleCode( 'span25',
- 'BorderCommonWidth.html#mappedPoints', '50%', '100%' )" ><span
+ 'BorderCommonWidth.html#mappedPoints', '400', '100%' )" ><span
class="codefrag">double[] mappedPoints</span></a>. The
entries in this array must by maintained in syncronization
with the <span id = "span26" ></span ><a href=
"javascript:toggleCode( 'span26',
- 'BorderCommonWidth.html#rwEnums', '50%', '100%' )" ><span
+ 'BorderCommonWidth.html#rwEnums', '400', '100%' )" ><span
class="codefrag">String[] rwEnums</span></a> array of tokens
and the set of <span id = "span27" ></span ><a href=
"javascript:toggleCode( 'span27',
- 'BorderCommonWidth.html#THIN', '50%', '100%' )" >enumeration
+ 'BorderCommonWidth.html#THIN', '400', '100%' )" >enumeration
constants</a>. The mapping from token to Numeric value is
achieved by the <span id = "span28" ></span ><a href=
"javascript:toggleCode( 'span28',
- 'BorderCommonWidth.html#getMappedLength', '50%', '100%' )"
+ 'BorderCommonWidth.html#getMappedLength', '400', '100%' )"
><span class="codefrag">Numeric getMappedLength(FONode, int,
int)</span></a> method.
</p>
<p>
<span id = "span29" ></span ><a href= "javascript:toggleCode(
- 'span29', 'BorderLeftWidth.html#BorderLeftWidthClass', '50%',
+ 'span29', 'BorderLeftWidth.html#BorderLeftWidthClass', '400',
'100%' )" ><span class="codefrag">BorderLeftWidth</span></a>
extends <span id = "span30" ></span ><a href=
"javascript:toggleCode( 'span30', 'BorderCommonWidth.html',
- '50%', '100%' )" ><span
+ '400', '100%' )" ><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 <span id = "span31" ></span ><a href=
"javascript:toggleCode( 'span31',
- 'BorderLeftWidth.html#getInitialValue', '50%', '100%' )"
+ 'BorderLeftWidth.html#getInitialValue', '400', '100%' )"
><span class="codefrag">PropertyValue
getInitialValue(int)</span></a> method to derive the initial
value.
As usual with property values, the usual method of deriving a
mapped numeric value is by calling the <span id = "span32"
></span ><a href= "javascript:toggleCode( 'span32',
- '../PropertyConsts.html#getMappedNumeric', '50%', '100%' )"
+ '../PropertyConsts.html#getMappedNumeric', '400', '100%' )"
><span class="codefrag">Numeric getMappedNumeric(FONode, int,
int)</span></a> method in <span id = "span33" ></span ><a
href= "javascript:toggleCode( 'span33',
- '../PropertyConsts.html#pconsts', '50%', '100%' )" ><span
+ '../PropertyConsts.html#pconsts', '400', '100%' )" ><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 <span id = "span34" ></span ><a href=
"javascript:toggleCode( 'span34',
- 'PropertyConsts.html#properties', '50%', '100%' )" ><span
+ 'PropertyConsts.html#properties', '400', '100%' )" ><span
class= "codefrag" >properties</span ></a> array, by the <span
class="codefrag">PropertyConsts</span> method.
</p>
<META http-equiv="Content-Type" content="text/html;
charset=ISO-8859-1" />
<title>Generating Initial Values</title>
- <script type="text/javascript" src="scripts/codedisplay.js">
- </script>
</head>
<body marginheight="0" marginwidth="0" topmargin="0" leftmargin="0" text="#000000" bgcolor="#FFFFFF">
+ <script type="text/javascript" src="codedisplay.js" />
<div class="content">
<h1>Generating Initial Values</h1>
<p>
<h3>
Generating & Accessing Initial Values
</h3>
+ <!-- N.B. height for toggleCode changed from 50% to 400 because
+ Mozilla seems to get confused by percentage heights within
+ table elements.
+ -->
<p>
<span id = "span00" ></span ><a href= "javascript:toggleCode(
- 'span00', 'AutoRestore.html', '50%', '100%' )" ><span
+ 'span00', 'AutoRestore.html', '400', '100%' )" ><span
class="codefrag"
>org.apache.fop.fo.properties.AutoRestore</span></a> is an
example of the next most complex property class. In addition
<p>
The method <span id = "span01" ></span ><a href=
"javascript:toggleCode( 'span01',
- 'AutoRestore.html#getInitialValue', '50%', '100%' )" ><span
+ 'AutoRestore.html#getInitialValue', '400', '100%' )" ><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 <span id = "span02"
></span ><a href= "javascript:toggleCode( 'span02',
- 'PropertyConsts.html#PropertyConstsClass', '50%', '100%' )"
+ 'PropertyConsts.html#PropertyConstsClass', '400', '100%' )"
><span class="codefrag">PropertyConsts</span></a> singleton
<span id = "span03" ></span ><a href= "javascript:toggleCode(
- 'span03', 'PropertyConsts.html#pconsts', '50%', '100%' )"
+ 'span03', 'PropertyConsts.html#pconsts', '400', '100%' )"
><span class="codefrag">pconsts</span></a>.` As with the
fields, the first invocation of the method <span id = "span04"
></span ><a href= "javascript:toggleCode( 'span04',
- 'PropertyConsts.html#setupProperty', '50%', '100%' )" ><span
+ 'PropertyConsts.html#setupProperty', '400', '100%' )" ><span
class="codefrag">setupProperty</span></a> on the property
instantiates the singleton instance of the class, and stores
that instance in the in the <span id = "span05" ></span ><a
href= "javascript:toggleCode( 'span05',
- 'PropertyConsts.html#properties', '50%', '100%' )" ><span
+ 'PropertyConsts.html#properties', '400', '100%' )" ><span
class="codefrag">Property[] properties</span></a> array of
<span id = "span06" ></span ><a href= "javascript:toggleCode(
- 'span06', 'PropertyConsts.html#pconsts', '50%', '100%' )"
+ 'span06', 'PropertyConsts.html#pconsts', '400', '100%' )"
><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 <span
id = "span07" ></span ><a href= "javascript:toggleCode(
- 'span07', 'PropertyConsts.html#getInitialValue', '50%', '100%'
+ 'span07', 'PropertyConsts.html#getInitialValue', '400', '100%'
)" ><span class="codefrag">PropertyValue
getInitialValue(int)</span></a> in <span id = "span08" ></span
><a href= "javascript:toggleCode( 'span08',
- 'PropertyConsts.html#pconsts', '50%', '100%' )" ><span
+ 'PropertyConsts.html#pconsts', '400', '100%' )" ><span
class="codefrag">pconsts</span></a>. This call, in turn,
locates the relevant instance of the particular property class
in the <span id = "span09" ></span ><a href=
"javascript:toggleCode( 'span09',
- 'PropertyConsts.html#properties', '50%', '100%' )" ><span
+ 'PropertyConsts.html#properties', '400', '100%' )" ><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
<span id = "span10" ></span ><a href= "javascript:toggleCode(
- 'span10', 'PropertyConsts.html#initialValues', '50%', '100%'
+ 'span10', 'PropertyConsts.html#initialValues', '400', '100%'
)" ><span class="codefrag">PropertyValue[]
initialValues</span></a>.
</p>
previously</a>, all of the property classes extend <span
class="codefrag">org.apache.fop.fo.properties.Property</span>.
<span id = "span11" ></span ><a href= "javascript:toggleCode(
- 'span11', 'Property.html#PropertyClass', '50%', '100%' )"
+ 'span11', 'Property.html#PropertyClass', '400', '100%' )"
><span class="codefrag">Property</span></a> provides a base
<span id = "span12" ></span ><a href= "javascript:toggleCode(
- 'span12', 'Property.html#getInitialValue', '50%', '100%' )"
+ 'span12', 'Property.html#getInitialValue', '400', '100%' )"
><span class="codefrag">PropertyValue
getInitialValue(int)</span></a> method to which the simple
classes fall back. Note that it is only valid for <span
<META http-equiv="Content-Type" content="text/html;
charset=ISO-8859-1" />
<title>Property Expression Parsing</title>
- <script type="text/javascript" src="scripts/codedisplay.js">
- </script>
</head>
<body marginheight="0" marginwidth="0" topmargin="0" leftmargin="0" text="#000000" bgcolor="#FFFFFF">
+ <script type="text/javascript" src="codedisplay.js" />
<div class="content">
<h1>Property Expression Parsing</h1>
<p>
<a name="N10014"></a>
<h3>Property expression parsing</h3>
+ <!-- N.B. height for toggleCode changed from 50% to 400 because
+ Mozilla seems to get confused by percentage heights within
+ table elements.
+ -->
<p>
The parsing of property value expressions is handled by two
closely related classes: <span id = "span00" ></span ><a href=
"javascript:toggleCode( 'span00',
- 'PropertyTokenizer.html#PropertyTokenizerClass', '50%', '100%'
+ 'PropertyTokenizer.html#PropertyTokenizerClass', '400', '100%'
)" ><span class= "codefrag"
>org.apache.fop.fo.expr.PropertyTokenizer</span></a> and its
subclass, <span id = "span01" ></span ><a href=
"javascript:toggleCode( 'span01',
- 'PropertyParser.html#PropertyParserClass', '50%', '100%' )"
+ 'PropertyParser.html#PropertyParserClass', '400', '100%' )"
><span class= "codefrag"
>org.apache.fop.fo.expr.PropertyParser</span></a>, and by
<span class= "codefrag" >refineParsing(int, FONode,
as the name suggests, handles the tokenizing of the
expression, handing <span id = "span02" ></span ><a href=
"javascript:toggleCode( 'span02',
- 'PropertyTokenizer.html#EOF', '50%', '100%' )"
+ 'PropertyTokenizer.html#EOF', '400', '100%' )"
><em>tokens</em></a> back to its subclass, <span class=
"codefrag" >PropertyParser</span>. <span class= "codefrag"
>PropertyParser</span>, in turn, returns a <span id = "span03"
></span ><a href= "javascript:toggleCode( 'span03',
- 'PropertyValueList.html#PropertyValueListClass', '50%', '100%'
+ 'PropertyValueList.html#PropertyValueListClass', '400', '100%'
)" ><span class= "codefrag">PropertyValueList</span></a>, a
list of <span id = "span04" ></span ><a href=
"javascript:toggleCode( 'span04',
- 'PropertyValue.html#PropertyValueInterface', '50%', '100%' )"
+ 'PropertyValue.html#PropertyValueInterface', '400', '100%' )"
><span class= "codefrag">PropertyValue</span></a>s.
</p>
<p>
definitions from the <span class= "codefrag"
>org.apache.fop.datatypes</span> package, which include the
<span id = "span05" ></span ><a href= "javascript:toggleCode(
- 'span05', 'PropertyValue.html#NO_TYPE', '50%', '100%' )"
+ 'span05', 'PropertyValue.html#NO_TYPE', '400', '100%' )"
><span class= "codefrag" >PropertyValue</span> datatype
constant definitions</a>.
</p>
As mentioned above, the <span class= "codefrag"
>PropertyTokenizer</span> hands <span id = "span06" ></span
><a href= "javascript:toggleCode( 'span06',
- 'PropertyTokenizer.html#EOF', '50%', '100%' )"
+ 'PropertyTokenizer.html#EOF', '400', '100%' )"
><em>tokens</em></a> back to its subclass, <span class=
"codefrag" >PropertyParser</span>. Most of these tokens are
self-explanatory, but a few need further comment.
<p>
The parser returns a <span id = "span07" ></span ><a href=
"javascript:toggleCode( 'span07',
- 'PropertyValueList.html#PropertyValueListClass', '50%', '100%'
+ 'PropertyValueList.html#PropertyValueListClass', '400', '100%'
)" ><span class= "codefrag" >PropertyValueList</span ></a>,
necessary because of the possibility that a list of <span id =
"span08" ></span ><a href= "javascript:toggleCode( 'span08',
- 'PropertyValue.html#PropertyValueInterface', '50%', '100%' )"
+ 'PropertyValue.html#PropertyValueInterface', '400', '100%' )"
><span class= "codefrag" >PropertyValue</span ></a> elements
may be returned from the expressions of some properties.
</p>
<head>
<META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"/>
<title>Simple <property> Classes</title>
- <script type="text/javascript" src="resources/codedisplay.js">
- </script>
</head>
<body marginheight="0" marginwidth="0" topmargin="0" leftmargin="0" text="#000000" bgcolor="#FFFFFF">
+ <script type="text/javascript" src="codedisplay.js" />
<div class="content">
<h1>Simple <property> Classes</h1>
<p>
<a name="N10014"></a>
<h3>Introduction</h3>
+ <!-- N.B. height for toggleCode changed from 50% to 400 because
+ Mozilla seems to get confused by percentage heights within
+ table elements.
+ -->
<p>
An <a href="classes-overview.html">overview of the properties
and classes</a> involved in handling properties has already
keep in mind that the primary avenue of access to the data and
the methods of property classes is the <span id = "span00"
></span ><a href= "javascript:toggleCode( 'span00',
- 'PropertyConsts.html#PropertyConstsClass', '50%', '100%' )"
+ 'PropertyConsts.html#PropertyConstsClass', '400', '100%' )"
><span class="codefrag">PropertyConsts</span></a> class and
its singleton object.
</p>
<p>
<span id = "span01" ></span ><a href= "javascript:toggleCode(
- 'span01', 'Character.html', '50%', '100%' )" ><span
+ 'span01', 'Character.html', '400', '100%' )" ><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:
assigned to the property. The value is chosen from the data
type constants defined in <span id = "span02" ></span ><a
href= "javascript:toggleCode( 'span02',
- 'Property.html#NOTYPE', '50%', '100%' )" ><span
+ 'Property.html#NOTYPE', '400', '100%' )" ><span
class="codefrag">org.apache.fop.fo.properties.Property</span></a>,
and may consist of more than one of those constants,
bit-ORed together.
the <span class="codefrag">Area tree</span>. The value is
chosen from the trait mapping constants defined in <span id
= "span03" ></span ><a href= "javascript:toggleCode(
- 'span03', 'Property.html#NO_TRAIT', '50%', '100%' )" ><span
+ 'span03', 'Property.html#NO_TRAIT', '400', '100%' )" ><span
class="codefrag">org.apache.fop.fo.properties.Property</span></a>,
and may consist of more than one of those constants,
bit-ORed together.
assigned to the property. The value is chosen from the
initial value type constants defined in <span id = "span04"
></span ><a href= "javascript:toggleCode( 'span04',
- 'Property.html#NOTYPE_IT', '50%', '100%' )" ><span
+ 'Property.html#NOTYPE_IT', '400', '100%' )" ><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
This field defines the kind of inheritance applicable to the
property. The value is chosen from the inheritance
constants defined in <span id = "span05" ></span ><a href=
- "javascript:toggleCode( 'span05', 'Property.html#NO', '50%',
+ "javascript:toggleCode( 'span05', 'Property.html#NO', '400',
'100%' )" ><span
class="codefrag">org.apache.fop.fo.properties.Property</span></a>.
</dd>
The constants above are generally accessed through the arrays
maintained in the <span id = "span06" ></span ><a href=
"javascript:toggleCode( 'span06',
- 'PropertyConsts.html#PropertyConstsClass', '50%', '100%' )"
+ 'PropertyConsts.html#PropertyConstsClass', '400', '100%' )"
><span class="codefrag">PropertyConsts</span></a> singleton
<span id = "span07" ></span ><a href= "javascript:toggleCode(
- 'span07', 'PropertyConsts.html#pconsts', '50%', '100%' )"
+ 'span07', 'PropertyConsts.html#pconsts', '400', '100%' )"
><span class="codefrag">pconsts</span></a>. The first
invocation of the method <span id = "span08" ></span ><a href=
"javascript:toggleCode( 'span08',
- 'PropertyConsts.html#setupProperty', '50%', '100%' )" ><span
+ 'PropertyConsts.html#setupProperty', '400', '100%' )" ><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 <span id = "span09"
></span ><a href= "javascript:toggleCode( 'span09',
- 'PropertyConsts.html#classes', '50%', '100%' )" ><span
+ 'PropertyConsts.html#classes', '400', '100%' )" ><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 <span id = "span10" ></span ><a href=
"javascript:toggleCode( 'span10',
- 'PropertyConsts.html#properties', '50%', '100%' )" ><span
+ 'PropertyConsts.html#properties', '400', '100%' )" ><span
class="codefrag">Property[] properties</span></a> array of
<span id = "span11" ></span ><a href= "javascript:toggleCode(
- 'span11', '../PropertyConsts.html#pconsts', '50%', '100%' )"
+ 'span11', '../PropertyConsts.html#pconsts', '400', '100%' )"
><span class="codefrag">pconsts</span></a>.
</p>
<p>
<span id = "span12" ></span ><a href=
"javascript:toggleCode( 'span12',
- 'PropertyConsts.html#datatypes', '50%', '100%' )" ><span
+ 'PropertyConsts.html#datatypes', '400', '100%' )" ><span
class="codefrag">int[] datatypes</span></a>
</dt>
<span id = "span13" ></span ><a href=
"javascript:toggleCode( 'span13',
- 'PropertyConsts.html#getDataTypes', '50%', '100%' )" ><span
+ 'PropertyConsts.html#getDataTypes', '400', '100%' )" ><span
class="codefrag">int getDataTypes(int)</span></a>
</dd>
<span id = "span14" ></span ><a href=
"javascript:toggleCode( 'span14',
- 'PropertyConsts.html#traitMappings', '50%', '100%' )" ><span
+ 'PropertyConsts.html#traitMappings', '400', '100%' )" ><span
class="codefrag">int[] traitMappings</span></a>
</dt>
<span id = "span15" ></span ><a href=
"javascript:toggleCode( 'span15',
- 'PropertyConsts.html#initialValueTypes', '50%', '100%' )"
+ 'PropertyConsts.html#initialValueTypes', '400', '100%' )"
><span class="codefrag">int[] initialValueTypes</span></a>
</dt>
<span id = "span16" ></span ><a href=
"javascript:toggleCode( 'span16',
- 'PropertyConsts.html#getInitialValueType', '50%', '100%' )"
+ 'PropertyConsts.html#getInitialValueType', '400', '100%' )"
><span class="codefrag">int
getInitialValueType(int)</span></a>
<span id = "span17" ></span ><a href=
"javascript:toggleCode( 'span17',
- 'PropertyConsts.html#inherited', '50%', '100%' )" ><span
+ 'PropertyConsts.html#inherited', '400', '100%' )" ><span
class="codefrag">int[] inherited</span></a>
</dt>
<span id = "span18" ></span ><a href=
"javascript:toggleCode( 'span18',
- 'PropertyConsts.html#inheritance', '50%', '100%' )" ><span
+ 'PropertyConsts.html#inheritance', '400', '100%' )" ><span
class="codefrag">int inheritance(int)</span></a>
</dd>
projects / xmlgraphics-fop.git / commitdiff