[FOray-commit] SF.net SVN: foray: [9188] trunk/foray
Modular XSL-FO Implementation for Java.
Status: Alpha
Brought to you by:
victormote
Menu
▾
▴
[FOray-commit] SF.net SVN: foray: [9188] trunk/foray
|
From: <vic...@us...> - 2007-04-13 23:59:06
|
Revision: 9188
http://svn.sourceforge.net/foray/?rev=9188&view=rev
Author: victormote
Date: 2007-04-13 16:58:59 -0700 (Fri, 13 Apr 2007)
Log Message:
-----------
Conform to axsl changes using typesafe enums.
Modified Paths:
--------------
trunk/foray/foray-areatree/src/java/org/foray/area/Area.java
trunk/foray/foray-areatree/src/java/org/foray/area/TextArea.java
trunk/foray/foray-fotree/src/java/org/foray/fotree/FOText.java
trunk/foray/foray-fotree/src/java/org/foray/fotree/FObj.java
trunk/foray/foray-fotree/src/java/org/foray/fotree/fo/obj/BookmarkTitle.java
trunk/foray/foray-fotree/src/java/org/foray/fotree/fo/prop/Enumerated.java
Modified: trunk/foray/foray-areatree/src/java/org/foray/area/Area.java
===================================================================
--- trunk/foray/foray-areatree/src/java/org/foray/area/Area.java 2007-04-13 20:18:09 UTC (rev 9187)
+++ trunk/foray/foray-areatree/src/java/org/foray/area/Area.java 2007-04-13 23:58:59 UTC (rev 9188)
@@ -41,9 +41,12 @@
import org.axsl.common.value.DisplayAlign;
import org.axsl.common.value.LinkType;
import org.axsl.common.value.Overflow;
+import org.axsl.common.value.ReferenceOrientation;
import org.axsl.common.value.RelativeAxis;
+import org.axsl.common.value.RelativePosition;
import org.axsl.common.value.Scaling;
import org.axsl.common.value.TextAlign;
+import org.axsl.common.value.WhiteSpaceTreatment;
import org.axsl.common.value.WrapOption;
import org.axsl.common.value.WritingMode;
import org.axsl.foR.Fo;
@@ -307,7 +310,7 @@
* @return The relative-position for this area.
* @see Fo#traitRelativePosition(FoContext)
*/
- public FoValue traitRelativePosition() {
+ public RelativePosition traitRelativePosition() {
return traitGeneratedBy().traitRelativePosition(this);
}
@@ -1305,7 +1308,7 @@
* Returns the reference-orientation trait for this area.
* @return The reference-orientation trait for this area.
*/
- public FoValue traitReferenceOrientation() {
+ public ReferenceOrientation traitReferenceOrientation() {
return traitGeneratedBy().traitReferenceOrientation(this);
}
@@ -1345,7 +1348,7 @@
* @return The whitespace-treatment trait for this area.
* @see Fo#traitWhiteSpaceTreatment(FoContext)
*/
- public FoValue traitWhiteSpaceTreatment() {
+ public WhiteSpaceTreatment traitWhiteSpaceTreatment() {
return traitGeneratedBy().traitWhiteSpaceTreatment(this);
}
Modified: trunk/foray/foray-areatree/src/java/org/foray/area/TextArea.java
===================================================================
--- trunk/foray/foray-areatree/src/java/org/foray/area/TextArea.java 2007-04-13 20:18:09 UTC (rev 9187)
+++ trunk/foray/foray-areatree/src/java/org/foray/area/TextArea.java 2007-04-13 23:58:59 UTC (rev 9188)
@@ -32,10 +32,10 @@
import org.foray.common.XMLCharacter;
import org.axsl.areaR.RenderVisitor;
-import org.axsl.foR.fo.FoValue;
+import org.axsl.common.value.WhiteSpaceTreatment;
+import org.axsl.foR.Fo;
import org.axsl.foR.FoNode;
import org.axsl.foR.FoTextContent;
-import org.axsl.foR.Fo;
import org.axsl.foR.fo.RetrieveMarker;
import org.axsl.fontR.Font;
import org.axsl.fontR.FontUse;
@@ -423,17 +423,18 @@
*/
public static int ignoreAtStart(final char[] chars, final int start,
final int size, final boolean firstItemOnLine,
- final FoValue whiteSpaceTreatment) {
+ final WhiteSpaceTreatment whiteSpaceTreatment) {
// Only eat leading whitespaces if this is the first item on the line.
if (! firstItemOnLine) {
return 0;
}
- if (whiteSpaceTreatment == FoValue.IGNORE
- || whiteSpaceTreatment == FoValue.PRESERVE) {
+ if (whiteSpaceTreatment == WhiteSpaceTreatment.IGNORE
+ || whiteSpaceTreatment == WhiteSpaceTreatment.PRESERVE) {
// These situations were totally handled in FOTree
return 0;
}
- if (whiteSpaceTreatment == FoValue.IGNORE_IF_BEFORE_LINEFEED) {
+ if (whiteSpaceTreatment
+ == WhiteSpaceTreatment.IGNORE_IF_BEFORE_LINEFEED) {
// Handled in ignoreAtEnd();
return 0;
}
@@ -466,17 +467,18 @@
*/
public static int ignoreAtEnd(final char[] chars, final int start,
final int size, final boolean lastItemOnLine,
- final FoValue whiteSpaceTreatment) {
+ final WhiteSpaceTreatment whiteSpaceTreatment) {
// Only eat trailing whitespaces if this is the last item on the line.
if (! lastItemOnLine) {
return 0;
}
- if (whiteSpaceTreatment == FoValue.IGNORE
- || whiteSpaceTreatment == FoValue.PRESERVE) {
+ if (whiteSpaceTreatment == WhiteSpaceTreatment.IGNORE
+ || whiteSpaceTreatment == WhiteSpaceTreatment.PRESERVE) {
// These situations were totally handled in FOTree
return 0;
}
- if (whiteSpaceTreatment == FoValue.IGNORE_IF_AFTER_LINEFEED) {
+ if (whiteSpaceTreatment
+ == WhiteSpaceTreatment.IGNORE_IF_AFTER_LINEFEED) {
// Handled in ignoreAtStart();
return 0;
}
Modified: trunk/foray/foray-fotree/src/java/org/foray/fotree/FOText.java
===================================================================
--- trunk/foray/foray-fotree/src/java/org/foray/fotree/FOText.java 2007-04-13 20:18:09 UTC (rev 9187)
+++ trunk/foray/foray-fotree/src/java/org/foray/fotree/FOText.java 2007-04-13 23:58:59 UTC (rev 9188)
@@ -32,6 +32,9 @@
import org.foray.common.XMLCharacter;
import org.foray.fotree.fo.obj.BookmarkTitle;
+import org.axsl.common.value.LinefeedTreatment;
+import org.axsl.common.value.TextTransform;
+import org.axsl.common.value.WhiteSpaceTreatment;
import org.axsl.common.value.WrapOption;
import org.axsl.foR.FoContext;
import org.axsl.foR.FoLineText;
@@ -188,9 +191,9 @@
final char[] charArray = getPreTextTransformText(context);
// Now handle text-transform.
- final FoValue textTransform = effectiveParent.traitTextTransform(
+ final TextTransform textTransform = effectiveParent.traitTextTransform(
context);
- if (textTransform != FoValue.NONE) {
+ if (textTransform != TextTransform.NONE) {
for (int i = 0; i < charArray.length; i++) {
charArray[i] = applyTextTransform(context, charArray, i,
textTransform);
@@ -256,7 +259,7 @@
*/
private char applyTextTransform(final FoContext context,
final char[] charArray, final int index,
- final FoValue textTransform) {
+ final TextTransform textTransform) {
final char c = charArray[index];
switch (textTransform) {
/* This method not be entered if value is NONE. */
@@ -826,7 +829,7 @@
* should therefore never be in the input.
*/
public static char applyWhiteSpaceTreatment(final char[] charArray,
- final int index, final FoValue whiteSpaceTreatment) {
+ final int index, final WhiteSpaceTreatment whiteSpaceTreatment) {
final char c = charArray[index];
if (! XMLCharacter.isXMLWhitespace(c)) {
/* If it is not whitespace, it cannot be changed. */
@@ -908,8 +911,8 @@
* Otherwise, a new char array with the result is returned.
*/
public static char[] applyWhiteSpaceTreatment(final char[] charArray,
- final FoValue inputWhiteSpaceTreatment) {
- FoValue whiteSpaceTreatment = inputWhiteSpaceTreatment;
+ final WhiteSpaceTreatment inputWhiteSpaceTreatment) {
+ WhiteSpaceTreatment whiteSpaceTreatment = inputWhiteSpaceTreatment;
switch (whiteSpaceTreatment) {
case IGNORE:
case PRESERVE:
@@ -923,7 +926,7 @@
/* Invalid value. Silently convert to the default value as specified
* in the standard . */
whiteSpaceTreatment =
- FoValue.IGNORE_IF_SURROUNDING_LINEFEED;
+ WhiteSpaceTreatment.IGNORE_IF_SURROUNDING_LINEFEED;
}
}
@@ -971,7 +974,7 @@
* removed.
*/
public static char applyLinefeedTreatment(final char c,
- final FoValue linefeedTreatment) {
+ final LinefeedTreatment linefeedTreatment) {
assert c == WKConstants.LINEFEED : "Invalid linefeed-treatment input.";
switch (linefeedTreatment) {
case IGNORE: {
@@ -1005,8 +1008,8 @@
* result is returned.
*/
public static char[] applyLinefeedTreatment(final char[] charArray,
- final FoValue inputLinefeedTreatment) {
- FoValue linefeedTreatment = inputLinefeedTreatment;
+ final LinefeedTreatment inputLinefeedTreatment) {
+ LinefeedTreatment linefeedTreatment = inputLinefeedTreatment;
switch (linefeedTreatment) {
case PRESERVE: {
return charArray;
@@ -1020,7 +1023,7 @@
default: {
/* Invalid value. Silently convert to the default, as specified by
* the standard. */
- linefeedTreatment = FoValue.TREAT_AS_SPACE;
+ linefeedTreatment = LinefeedTreatment.TREAT_AS_SPACE;
}
}
@@ -1029,7 +1032,7 @@
for (int i = 0; i < charArray.length; i++) {
final char c = charArray[i];
if (c == WKConstants.LINEFEED) {
- if (linefeedTreatment == FoValue.IGNORE) {
+ if (linefeedTreatment == LinefeedTreatment.IGNORE) {
discardElements ++;
} else {
changeElements ++;
Modified: trunk/foray/foray-fotree/src/java/org/foray/fotree/FObj.java
===================================================================
--- trunk/foray/foray-fotree/src/java/org/foray/fotree/FObj.java 2007-04-13 20:18:09 UTC (rev 9187)
+++ trunk/foray/foray-fotree/src/java/org/foray/fotree/FObj.java 2007-04-13 23:58:59 UTC (rev 9188)
@@ -39,29 +39,54 @@
import org.axsl.common.value.AbsoluteAxis;
import org.axsl.common.value.AbsoluteDirection;
import org.axsl.common.value.AbsolutePosition;
+import org.axsl.common.value.ActiveState;
import org.axsl.common.value.BackgroundAttachment;
import org.axsl.common.value.BackgroundRepeat;
import org.axsl.common.value.Baseline;
import org.axsl.common.value.BorderModel;
import org.axsl.common.value.BorderStyle;
import org.axsl.common.value.Break;
+import org.axsl.common.value.Clear;
import org.axsl.common.value.Conditionality;
import org.axsl.common.value.DisplayAlign;
+import org.axsl.common.value.EmptyCells;
+import org.axsl.common.value.Float;
import org.axsl.common.value.ForcePageCount;
+import org.axsl.common.value.HyphenationKeep;
import org.axsl.common.value.LeaderAlignment;
import org.axsl.common.value.LeaderPattern;
+import org.axsl.common.value.LineHeightShiftAdjustment;
+import org.axsl.common.value.LineStackingStrategy;
+import org.axsl.common.value.LinefeedTreatment;
+import org.axsl.common.value.MediaUsage;
import org.axsl.common.value.Overflow;
+import org.axsl.common.value.ReferenceOrientation;
import org.axsl.common.value.RelativeAlign;
import org.axsl.common.value.RelativeAxis;
import org.axsl.common.value.RelativeCompass;
+import org.axsl.common.value.RelativePosition;
+import org.axsl.common.value.RenderingIntent;
import org.axsl.common.value.RuleStyle;
import org.axsl.common.value.Scaling;
+import org.axsl.common.value.ScalingMethod;
import org.axsl.common.value.ShadowEffect;
import org.axsl.common.value.Shape;
+import org.axsl.common.value.ShowDestination;
import org.axsl.common.value.Span;
+import org.axsl.common.value.Speak;
+import org.axsl.common.value.SpeakHeader;
+import org.axsl.common.value.SpeakNumeral;
+import org.axsl.common.value.SpeakPunctuation;
+import org.axsl.common.value.StartingState;
+import org.axsl.common.value.SuppressAtLineBreak;
+import org.axsl.common.value.SwitchTo;
import org.axsl.common.value.TableLayout;
import org.axsl.common.value.TextAlign;
import org.axsl.common.value.TextAlignLast;
+import org.axsl.common.value.TextTransform;
+import org.axsl.common.value.UnicodeBidi;
+import org.axsl.common.value.Visibility;
+import org.axsl.common.value.WhiteSpaceTreatment;
import org.axsl.common.value.WrapOption;
import org.axsl.common.value.WritingMode;
import org.axsl.foR.FoContext;
@@ -2486,66 +2511,249 @@
}
/**
+ * Converts an {@link FoValue} hyphenation-keep value to the more
+ * generic {@link HyphenationKeep} value.
+ * @param foHyphenationKeep The raw FO hyphenation-keep to be converted.
+ * @return The matching HyphenationKeep instance.
+ */
+ private static HyphenationKeep convertHyphenationKeep(
+ final FoValue foHyphenationKeep) {
+ switch (foHyphenationKeep) {
+ case AUTO: return HyphenationKeep.AUTO;
+ case COLUMN: return HyphenationKeep.COLUMN;
+ case PAGE: return HyphenationKeep.PAGE;
+ default: throw new IllegalArgumentException("Illegal hyphenation-keep: "
+ + foHyphenationKeep.toXslFo());
+ }
+ }
+
+ /**
* {@inheritDoc}
*/
- public FoValue traitHyphenationKeep(final FoContext context) {
- return propertyList.traitHyphenationKeep(context);
+ public HyphenationKeep traitHyphenationKeep(final FoContext context) {
+ final FoValue foValue = propertyList.traitHyphenationKeep(context);
+ return convertHyphenationKeep(foValue);
}
/**
+ * Converts an {@link FoValue} linefeed-treatment value to the more
+ * generic {@link LinefeedTreatment} value.
+ * @param foLinefeedTreatment The raw FO linefeed-treatment to be converted.
+ * @return The matching LinefeedTreatment instance.
+ */
+ private static LinefeedTreatment convertLinefeedTreatment(
+ final FoValue foLinefeedTreatment) {
+ switch (foLinefeedTreatment) {
+ case IGNORE: return LinefeedTreatment.IGNORE;
+ case PRESERVE: return LinefeedTreatment.PRESERVE;
+ case TREAT_AS_SPACE: return LinefeedTreatment.TREAT_AS_SPACE;
+ case TREAT_AS_ZERO_WIDTH_SPACE:
+ return LinefeedTreatment.TREAT_AS_ZERO_WIDTH_SPACE;
+ default: throw new IllegalArgumentException(
+ "Illegal linefeed-treatment: "
+ + foLinefeedTreatment.toXslFo());
+ }
+ }
+
+ /**
* {@inheritDoc}
*/
- public FoValue traitLinefeedTreatment(final FoContext context) {
- return propertyList.traitLinefeedTreatment(context);
+ public LinefeedTreatment traitLinefeedTreatment(final FoContext context) {
+ final FoValue foValue = propertyList.traitLinefeedTreatment(context);
+ return convertLinefeedTreatment(foValue);
}
/**
+ * Converts an {@link FoValue} line-height-shift-adjustment value to the
+ * more generic {@link LineHeightShiftAdjustment} value.
+ * @param foLineHeightShiftAdjustment The raw FO
+ * line-height-shift-adjustment to be converted.
+ * @return The matching LineHeightShiftAdjustment instance.
+ */
+ private static LineHeightShiftAdjustment convertLineHeightShiftAdjustment(
+ final FoValue foLineHeightShiftAdjustment) {
+ switch (foLineHeightShiftAdjustment) {
+ case CONSIDER_SHIFTS: return LineHeightShiftAdjustment.CONSIDER_SHIFTS;
+ case DISREGARD_SHIFTS:
+ return LineHeightShiftAdjustment.DISREGARD_SHIFTS;
+ default: throw new IllegalArgumentException(
+ "Illegal line-height-shift-adjustment: "
+ + foLineHeightShiftAdjustment.toXslFo());
+ }
+ }
+
+ /**
* {@inheritDoc}
*/
- public FoValue traitLineHeightShiftAdjustment(final FoContext context) {
- return propertyList.traitLineHeightShiftAdjustment(context);
+ public LineHeightShiftAdjustment traitLineHeightShiftAdjustment(
+ final FoContext context) {
+ final FoValue foValue = propertyList.traitLineHeightShiftAdjustment(
+ context);
+ return convertLineHeightShiftAdjustment(foValue);
}
/**
+ * Converts an {@link FoValue} line-stacking-strategy value to the more
+ * generic {@link LineStackingStrategy} value.
+ * @param foLineStackingStrategy The raw FO line-stacking-strategy to be
+ * converted.
+ * @return The matching LineStackingStrategy instance.
+ */
+ private static LineStackingStrategy convertLineStackingStrategy(
+ final FoValue foLineStackingStrategy) {
+ switch (foLineStackingStrategy) {
+ case LINE_HEIGHT: return LineStackingStrategy.LINE_HEIGHT;
+ case FONT_HEIGHT: return LineStackingStrategy.FONT_HEIGHT;
+ case MAX_HEIGHT: return LineStackingStrategy.MAX_HEIGHT;
+ default: throw new IllegalArgumentException(
+ "Illegal line-stacking-strategy: "
+ + foLineStackingStrategy.toXslFo());
+ }
+ }
+
+ /**
* {@inheritDoc}
*/
- public FoValue traitLineStackingStrategy(final FoContext context) {
- return propertyList.traitLineStackingStrategy(context);
+ public LineStackingStrategy traitLineStackingStrategy(
+ final FoContext context) {
+ final FoValue foValue = propertyList.traitLineStackingStrategy(context);
+ return convertLineStackingStrategy(foValue);
}
/**
+ * Converts an {@link FoValue} relative-position value to the more
+ * generic {@link RelativePosition} value.
+ * @param foRelativePosition The raw FO relative-position to be converted.
+ * @return The matching RelativePosition instance.
+ */
+ private static RelativePosition convertRelativePosition(
+ final FoValue foRelativePosition) {
+ switch (foRelativePosition) {
+ case STATIC: return RelativePosition.STATIC;
+ case RELATIVE: return RelativePosition.RELATIVE;
+ default: throw new IllegalArgumentException(
+ "Illegal relative-position: "
+ + foRelativePosition.toXslFo());
+ }
+ }
+
+ /**
* {@inheritDoc}
*/
- public FoValue traitRelativePosition(final FoContext context) {
- return propertyList.traitRelativePosition(context);
+ public RelativePosition traitRelativePosition(final FoContext context) {
+ final FoValue foValue = propertyList.traitRelativePosition(context);
+ return convertRelativePosition(foValue);
}
/**
+ * Converts an {@link FoValue} scaling-method value to the more
+ * generic {@link ScalingMethod} value.
+ * @param foScalingMethod The raw FO scaling-method to be converted.
+ * @return The matching ScalingMethod instance.
+ */
+ private static ScalingMethod convertScalingMethod(
+ final FoValue foScalingMethod) {
+ switch (foScalingMethod) {
+ case AUTO: return ScalingMethod.AUTO;
+ case INTEGER_PIXELS: return ScalingMethod.INTEGER_PIXELS;
+ case RESAMPLE_ANY_METHOD: return ScalingMethod.RESAMPLE_ANY_METHOD;
+ default: throw new IllegalArgumentException("Illegal scaling-method: "
+ + foScalingMethod.toXslFo());
+ }
+ }
+
+ /**
* {@inheritDoc}
*/
- public FoValue traitScalingMethod(final FoContext context) {
- return propertyList.traitScalingMethod(context);
+ public ScalingMethod traitScalingMethod(final FoContext context) {
+ final FoValue foValue = propertyList.traitScalingMethod(context);
+ return convertScalingMethod(foValue);
}
/**
+ * Converts an {@link FoValue} suppress-at-line-break value to the more
+ * generic {@link SuppressAtLineBreak} value.
+ * @param foSuppressAtLineBreak The raw FO suppress-at-line-break to be
+ * converted.
+ * @return The matching SuppressAtLineBreak instance.
+ */
+ private static SuppressAtLineBreak convertSuppressAtLineBreak(
+ final FoValue foSuppressAtLineBreak) {
+ switch (foSuppressAtLineBreak) {
+ case AUTO: return SuppressAtLineBreak.AUTO;
+ case SUPPRESS: return SuppressAtLineBreak.SUPPRESS;
+ case RETAIN: return SuppressAtLineBreak.RETAIN;
+ default: throw new IllegalArgumentException(
+ "Illegal suppress-at-line-break: "
+ + foSuppressAtLineBreak.toXslFo());
+ }
+ }
+
+ /**
* {@inheritDoc}
*/
- public FoValue traitSuppressAtLineBreak(final FoContext context) {
- return propertyList.traitSuppressAtLineBreak(context);
+ public SuppressAtLineBreak traitSuppressAtLineBreak(
+ final FoContext context) {
+ final FoValue foValue = propertyList.traitSuppressAtLineBreak(context);
+ return convertSuppressAtLineBreak(foValue);
}
/**
+ * Converts an {@link FoValue} unicode-bidi value to the more
+ * generic {@link UnicodeBidi} value.
+ * @param foUnicodeBidi The raw FO unicode-bidi to be converted.
+ * @return The matching UnicodeBidi instance.
+ */
+ private static UnicodeBidi convertUnicodeBidi(
+ final FoValue foUnicodeBidi) {
+ switch (foUnicodeBidi) {
+ case NORMAL: return UnicodeBidi.NORMAL;
+ case EMBED: return UnicodeBidi.EMBED;
+ case BIDI_OVERRIDE: return UnicodeBidi.BIDI_OVERRIDE;
+ default: throw new IllegalArgumentException("Illegal unicode-bidi: "
+ + foUnicodeBidi.toXslFo());
+ }
+ }
+
+ /**
* {@inheritDoc}
*/
- public FoValue traitUnicodeBidi(final FoContext context) {
- return propertyList.traitUnicodeBidi(context);
+ public UnicodeBidi traitUnicodeBidi(final FoContext context) {
+ final FoValue foValue = propertyList.traitUnicodeBidi(context);
+ return convertUnicodeBidi(foValue);
}
/**
+ * Converts an {@link FoValue} white-space-treatment value to the more
+ * generic {@link WhiteSpaceTreatment} value.
+ * @param foWhiteSpaceTreatment The raw FO white-space-treatment to be
+ * converted.
+ * @return The matching WhiteSpaceTreatment instance.
+ */
+ private static WhiteSpaceTreatment convertWhiteSpaceTreatment(
+ final FoValue foWhiteSpaceTreatment) {
+ switch (foWhiteSpaceTreatment) {
+ case IGNORE: return WhiteSpaceTreatment.IGNORE;
+ case PRESERVE: return WhiteSpaceTreatment.PRESERVE;
+ case IGNORE_IF_BEFORE_LINEFEED:
+ return WhiteSpaceTreatment.IGNORE_IF_BEFORE_LINEFEED;
+ case IGNORE_IF_AFTER_LINEFEED:
+ return WhiteSpaceTreatment.IGNORE_IF_AFTER_LINEFEED;
+ case IGNORE_IF_SURROUNDING_LINEFEED:
+ return WhiteSpaceTreatment.IGNORE_IF_SURROUNDING_LINEFEED;
+ default: throw new IllegalArgumentException(
+ "Illegal white-space-treatment: "
+ + foWhiteSpaceTreatment.toXslFo());
+ }
+ }
+
+ /**
* {@inheritDoc}
*/
- public FoValue traitWhiteSpaceTreatment(final FoContext context) {
- return propertyList.traitWhiteSpaceTreatment(context);
+ public WhiteSpaceTreatment traitWhiteSpaceTreatment(
+ final FoContext context) {
+ final FoValue foValue = propertyList.traitWhiteSpaceTreatment(context);
+ return convertWhiteSpaceTreatment(foValue);
}
/**
@@ -2556,115 +2764,395 @@
}
/**
+ * Converts an {@link FoValue} active-state value to the more
+ * generic {@link ActiveState} value.
+ * @param foActiveState The raw FO active-state to be converted.
+ * @return The matching ActiveState instance.
+ */
+ private static ActiveState convertActiveState(
+ final FoValue foActiveState) {
+ switch (foActiveState) {
+ case LINK: return ActiveState.LINK;
+ case VISITED: return ActiveState.VISITED;
+ case ACTIVE: return ActiveState.ACTIVE;
+ case HOVER: return ActiveState.HOVER;
+ case FOCUS: return ActiveState.FOCUS;
+ default: throw new IllegalArgumentException("Illegal active-state: "
+ + foActiveState.toXslFo());
+ }
+ }
+
+ /**
* {@inheritDoc}
*/
- public FoValue traitActiveState(final FoContext context) {
- return propertyList.traitActiveState(context);
+ public ActiveState traitActiveState(final FoContext context) {
+ final FoValue foValue = propertyList.traitActiveState(context);
+ return convertActiveState(foValue);
}
/**
+ * Converts an {@link FoValue} clear value to the more
+ * generic {@link Clear} value.
+ * @param foClear The raw FO clear to be converted.
+ * @return The matching Clear instance.
+ */
+ private static Clear convertClear(final FoValue foClear) {
+ switch (foClear) {
+ case START: return Clear.START;
+ case END: return Clear.END;
+ case INSIDE: return Clear.INSIDE;
+ case OUTSIDE: return Clear.OUTSIDE;
+ case BOTH: return Clear.BOTH;
+ case NONE: return Clear.NONE;
+ default: throw new IllegalArgumentException("Illegal clear: "
+ + foClear.toXslFo());
+ }
+ }
+
+ /**
* {@inheritDoc}
*/
- public FoValue traitClear(final FoContext context) {
- return propertyList.traitClear(context);
+ public Clear traitClear(final FoContext context) {
+ final FoValue foValue = propertyList.traitClear(context);
+ return convertClear(foValue);
}
/**
+ * Converts an {@link FoValue} empty-cells value to the more
+ * generic {@link EmptyCells} value.
+ * @param foEmptyCells The raw FO empty-cells to be converted.
+ * @return The matching EmptyCells instance.
+ */
+ private static EmptyCells convertEmptyCells(final FoValue foEmptyCells) {
+ switch (foEmptyCells) {
+ case SHOW: return EmptyCells.SHOW;
+ case HIDE: return EmptyCells.HIDE;
+ default: throw new IllegalArgumentException("Illegal empty-cells: "
+ + foEmptyCells.toXslFo());
+ }
+ }
+
+ /**
* {@inheritDoc}
*/
- public FoValue traitEmptyCells(final FoContext context) {
- return propertyList.traitEmptyCells(context);
+ public EmptyCells traitEmptyCells(final FoContext context) {
+ final FoValue foValue = propertyList.traitEmptyCells(context);
+ return convertEmptyCells(foValue);
}
/**
+ * Converts an {@link FoValue} float value to the more
+ * generic {@link Float} value.
+ * @param foFloat The raw FO float to be converted.
+ * @return The matching Float instance.
+ */
+ private static Float convertFloat(
+ final FoValue foFloat) {
+ switch (foFloat) {
+ case BEFORE: return Float.BEFORE;
+ case START: return Float.START;
+ case END: return Float.END;
+ case INSIDE: return Float.INSIDE;
+ case OUTSIDE: return Float.OUTSIDE;
+ case NONE: return Float.NONE;
+ default: throw new IllegalArgumentException("Illegal float: "
+ + foFloat.toXslFo());
+ }
+ }
+
+ /**
* {@inheritDoc}
*/
- public FoValue traitFloat(final FoContext context) {
- return propertyList.traitFloat(context);
+ public org.axsl.common.value.Float traitFloat(final FoContext context) {
+ final FoValue foValue = propertyList.traitFloat(context);
+ return convertFloat(foValue);
}
/**
+ * Converts an {@link FoValue} media-usage value to the more
+ * generic {@link MediaUsage} value.
+ * @param foMediaUsage The raw FO media-usage to be converted.
+ * @return The matching MediaUsage instance.
+ */
+ private static MediaUsage convertMediaUsage(final FoValue foMediaUsage) {
+ switch (foMediaUsage) {
+ case PAGINATE: return MediaUsage.PAGINATE;
+ case BOUNDED_IN_ONE_DIMENSION:
+ return MediaUsage.BOUNDED_IN_ONE_DIMENSION;
+ case UNBOUNDED: return MediaUsage.UNBOUNDED;
+ default: throw new IllegalArgumentException("Illegal media-usage: "
+ + foMediaUsage.toXslFo());
+ }
+ }
+
+ /**
* {@inheritDoc}
*/
- public FoValue traitMediaUsage(final FoContext context) {
- return propertyList.traitMediaUsage(context);
+ public MediaUsage traitMediaUsage(final FoContext context) {
+ final FoValue foValue = propertyList.traitMediaUsage(context);
+ return convertMediaUsage(foValue);
}
/**
+ * Converts an {@link FoValue} reference-orientation value to the more
+ * generic {@link ReferenceOrientation} value.
+ * @param foReferenceOrientation The raw FO reference-orientation to be
+ * converted.
+ * @return The matching ReferenceOrientation instance.
+ */
+ private static ReferenceOrientation convertReferenceOrientation(
+ final FoValue foReferenceOrientation) {
+ switch (foReferenceOrientation) {
+ case NUM_ZERO: return ReferenceOrientation.NUM_ZERO;
+ case NUM_90: return ReferenceOrientation.NUM_90;
+ case NUM_180: return ReferenceOrientation.NUM_180;
+ case NUM_270: return ReferenceOrientation.NUM_270;
+ case NUM_NEGATIVE_90: return ReferenceOrientation.NUM_270;
+ case NUM_NEGATIVE_180: return ReferenceOrientation.NUM_180;
+ case NUM_NEGATIVE_270: return ReferenceOrientation.NUM_90;
+ default: throw new IllegalArgumentException(
+ "Illegal reference-orientation: "
+ + foReferenceOrientation.toXslFo());
+ }
+ }
+
+ /**
* {@inheritDoc}
*/
- public FoValue traitReferenceOrientation(final FoContext context) {
- /*
- * Per XSL-FO Standard 1.0, Section 7.20.3, reference-orientation is
- * only applied to FOs that establish a reference-area.
- */
+ public ReferenceOrientation traitReferenceOrientation(
+ final FoContext context) {
+ /* Per XSL-FO Standard 1.0, Section 7.20.3, reference-orientation is
+ * only applied to FOs that establish a reference-area. */
if (isRAGenerator()) {
- return propertyList.traitReferenceOrientation(context);
+ final FoValue foValue = propertyList.traitReferenceOrientation(
+ context);
+ return convertReferenceOrientation(foValue);
}
return null;
}
/**
+ * Converts an {@link FoValue} rendering-intent value to the more
+ * generic {@link RenderingIntent} value.
+ * @param foRenderingIntent The raw FO rendering-intent to be converted.
+ * @return The matching RenderingIntent instance.
+ */
+ private static RenderingIntent convertRenderingIntent(
+ final FoValue foRenderingIntent) {
+ switch (foRenderingIntent) {
+ case AUTO: return RenderingIntent.AUTO;
+ case PERCEPTUAL: return RenderingIntent.PERCEPTUAL;
+ case RELATIVE_COLORIMETRIC:
+ return RenderingIntent.RELATIVE_COLORIMETRIC;
+ case SATURATION: return RenderingIntent.SATURATION;
+ case ABSOLUTE_COLORIMETRIC:
+ return RenderingIntent.ABSOLUTE_COLORIMETRIC;
+ default: throw new IllegalArgumentException("Illegal rendering-intent: "
+ + foRenderingIntent.toXslFo());
+ }
+ }
+
+ /**
* {@inheritDoc}
*/
- public FoValue traitRenderingIntent(final FoContext context) {
- return propertyList.traitRenderingIntent(context);
+ public RenderingIntent traitRenderingIntent(final FoContext context) {
+ final FoValue foValue = propertyList.traitRenderingIntent(context);
+ return convertRenderingIntent(foValue);
}
/**
+ * Converts an {@link FoValue} show-destination value to the more
+ * generic {@link ShowDestination} value.
+ * @param foShowDestination The raw FO show-destination to be converted.
+ * @return The matching ShowDestination instance.
+ */
+ private static ShowDestination convertShowDestination(
+ final FoValue foShowDestination) {
+ switch (foShowDestination) {
+ case REPLACE: return ShowDestination.REPLACE;
+ case NEW: return ShowDestination.NEW;
+ default: throw new IllegalArgumentException("Illegal show-destination: "
+ + foShowDestination.toXslFo());
+ }
+ }
+
+ /**
* {@inheritDoc}
*/
- public FoValue traitShowDestination(final FoContext context) {
- return propertyList.traitShowDestination(context);
+ public ShowDestination traitShowDestination(final FoContext context) {
+ final FoValue foValue = propertyList.traitShowDestination(context);
+ return convertShowDestination(foValue);
}
/**
+ * Converts an {@link FoValue} speak-header value to the more
+ * generic {@link SpeakHeader} value.
+ * @param foSpeakHeader The raw FO speak-header to be converted.
+ * @return The matching SpeakHeader instance.
+ */
+ private static SpeakHeader convertSpeakHeader(
+ final FoValue foSpeakHeader) {
+ switch (foSpeakHeader) {
+ case ONCE: return SpeakHeader.ONCE;
+ case ALWAYS: return SpeakHeader.ALWAYS;
+ default: throw new IllegalArgumentException("Illegal speak-header: "
+ + foSpeakHeader.toXslFo());
+ }
+ }
+
+ /**
* {@inheritDoc}
*/
- public FoValue traitSpeakHeader(final FoContext context) {
- return propertyList.traitSpeakHeader(context);
+ public SpeakHeader traitSpeakHeader(final FoContext context) {
+ final FoValue foValue = propertyList.traitSpeakHeader(context);
+ return convertSpeakHeader(foValue);
}
/**
+ * Converts an {@link FoValue} speak value to the more
+ * generic {@link Speak} value.
+ * @param foSpeak The raw FO speak to be converted.
+ * @return The matching Speak instance.
+ */
+ private static Speak convertSpeak(final FoValue foSpeak) {
+ switch (foSpeak) {
+ case NORMAL: return Speak.NORMAL;
+ case NONE: return Speak.NONE;
+ case SPELL_OUT: return Speak.SPELL_OUT;
+ default: throw new IllegalArgumentException("Illegal speak: "
+ + foSpeak.toXslFo());
+ }
+ }
+
+ /**
* {@inheritDoc}
*/
- public FoValue traitSpeak(final FoContext context) {
- return propertyList.traitSpeak(context);
+ public Speak traitSpeak(final FoContext context) {
+ final FoValue foValue = propertyList.traitSpeak(context);
+ return convertSpeak(foValue);
}
/**
+ * Converts an {@link FoValue} speak-numeral value to the more
+ * generic {@link SpeakNumeral} value.
+ * @param foSpeakNumeral The raw FO speak-numeral to be converted.
+ * @return The matching SpeakNumeral instance.
+ */
+ private static SpeakNumeral convertSpeakNumeral(
+ final FoValue foSpeakNumeral) {
+ switch (foSpeakNumeral) {
+ case DIGITS: return SpeakNumeral.DIGITS;
+ case CONTINUOUS: return SpeakNumeral.CONTINUOUS;
+ default: throw new IllegalArgumentException("Illegal speak-numeral: "
+ + foSpeakNumeral.toXslFo());
+ }
+ }
+
+ /**
* {@inheritDoc}
*/
- public FoValue traitSpeakNumeral(final FoContext context) {
- return propertyList.traitSpeakNumeral(context);
+ public SpeakNumeral traitSpeakNumeral(final FoContext context) {
+ final FoValue foValue = propertyList.traitSpeakNumeral(context);
+ return convertSpeakNumeral(foValue);
}
/**
+ * Converts an {@link FoValue} speak-punctuation value to the more
+ * generic {@link SpeakPunctuation} value.
+ * @param foSpeakPunctuation The raw FO speak-punctuation to be converted.
+ * @return The matching SpeakPunctuation instance.
+ */
+ private static SpeakPunctuation convertSpeakPunctuation(
+ final FoValue foSpeakPunctuation) {
+ switch (foSpeakPunctuation) {
+ case CODE: return SpeakPunctuation.CODE;
+ case NONE: return SpeakPunctuation.NONE;
+ default: throw new IllegalArgumentException(
+ "Illegal speak-punctuation: "
+ + foSpeakPunctuation.toXslFo());
+ }
+ }
+
+ /**
* {@inheritDoc}
*/
- public FoValue traitSpeakPunctuation(final FoContext context) {
- return propertyList.traitSpeakPunctuation(context);
+ public SpeakPunctuation traitSpeakPunctuation(final FoContext context) {
+ final FoValue foValue = propertyList.traitSpeakPunctuation(context);
+ return convertSpeakPunctuation(foValue);
}
/**
+ * Converts an {@link FoValue} starting-state value to the more
+ * generic {@link StartingState} value.
+ * @param foStartingState The raw FO starting-state to be converted.
+ * @return The matching StartingState instance.
+ */
+ private static StartingState convertStartingState(
+ final FoValue foStartingState) {
+ switch (foStartingState) {
+ case SHOW: return StartingState.SHOW;
+ case HIDE: return StartingState.HIDE;
+ default: throw new IllegalArgumentException("Illegal starting-state: "
+ + foStartingState.toXslFo());
+ }
+ }
+
+ /**
* {@inheritDoc}
*/
- public FoValue traitStartingState(final FoContext context) {
- return propertyList.traitStartingState(context);
+ public StartingState traitStartingState(final FoContext context) {
+ final FoValue foValue = propertyList.traitStartingState(context);
+ return convertStartingState(foValue);
}
/**
+ * Converts an {@link FoValue} text-transform value to the more
+ * generic {@link TextTransform} value.
+ * @param foTextTransform The raw FO text-transform to be converted.
+ * @return The matching TextTransform instance.
+ */
+ private static TextTransform convertTextTransform(
+ final FoValue foTextTransform) {
+ switch (foTextTransform) {
+ case CAPITALIZE: return TextTransform.CAPITALIZE;
+ case UPPERCASE: return TextTransform.UPPERCASE;
+ case LOWERCASE: return TextTransform.LOWERCASE;
+ case NONE: return TextTransform.NONE;
+ default: throw new IllegalArgumentException("Illegal text-transform: "
+ + foTextTransform.toXslFo());
+ }
+ }
+
+ /**
* {@inheritDoc}
*/
- public FoValue traitTextTransform(final FoContext context) {
- return propertyList.traitTextTransform(context);
+ public TextTransform traitTextTransform(final FoContext context) {
+ final FoValue foValue = propertyList.traitTextTransform(context);
+ return convertTextTransform(foValue);
}
/**
+ * Converts an {@link FoValue} visibility value to the more
+ * generic {@link Visibility} value.
+ * @param foVisibility The raw FO visibility to be converted.
+ * @return The matching Visibility instance.
+ */
+ private static Visibility convertVisibility(final FoValue foVisibility) {
+ switch (foVisibility) {
+ case VISIBLE: return Visibility.VISIBLE;
+ case HIDDEN: return Visibility.HIDDEN;
+ case COLLAPSE: return Visibility.COLLAPSE;
+ default: throw new IllegalArgumentException("Illegal visibility: "
+ + foVisibility.toXslFo());
+ }
+ }
+
+ /**
* {@inheritDoc}
*/
- public FoValue traitVisibility(final FoContext context) {
- return propertyList.traitVisibility(context);
+ public Visibility traitVisibility(final FoContext context) {
+ final FoValue foValue = propertyList.traitVisibility(context);
+ return convertVisibility(foValue);
}
/**
@@ -2872,10 +3360,29 @@
}
/**
+ * Converts an {@link FoValue} switch-to value to the more
+ * generic {@link SwitchTo} value.
+ * @param foSwitchTo The raw FO switch-to to be converted.
+ * @return The matching SwitchTo instance.
+ */
+ private static SwitchTo convertSwitchTo(
+ final FoValue foSwitchTo) {
+ switch (foSwitchTo) {
+ case XSL_PRECEDING: return SwitchTo.XSL_PRECEDING;
+ case XSL_FOLLOWING: return SwitchTo.XSL_FOLLOWING;
+ case XSL_ANY: return SwitchTo.XSL_ANY;
+ case NOT_A_KEYWORD: return SwitchTo.NAME_LIST;
+ default: throw new IllegalArgumentException("Illegal switch-to: "
+ + foSwitchTo.toXslFo());
+ }
+ }
+
+ /**
* {@inheritDoc}
*/
- public FoValue traitSwitchTo() {
- return propertyList.traitSwitchTo();
+ public SwitchTo traitSwitchTo() {
+ final FoValue foValue = propertyList.traitSwitchTo();
+ return convertSwitchTo(foValue);
}
/**
Modified: trunk/foray/foray-fotree/src/java/org/foray/fotree/fo/obj/BookmarkTitle.java
===================================================================
--- trunk/foray/foray-fotree/src/java/org/foray/fotree/fo/obj/BookmarkTitle.java 2007-04-13 20:18:09 UTC (rev 9187)
+++ trunk/foray/foray-fotree/src/java/org/foray/fotree/fo/obj/BookmarkTitle.java 2007-04-13 23:58:59 UTC (rev 9188)
@@ -34,10 +34,12 @@
import org.foray.fotree.Namespace;
import org.foray.fotree.PropertyList;
+import org.axsl.common.value.LinefeedTreatment;
+import org.axsl.common.value.TextTransform;
+import org.axsl.common.value.WhiteSpaceTreatment;
import org.axsl.foR.FoContext;
import org.axsl.foR.FoTreeException;
import org.axsl.foR.ProxyFactory;
-import org.axsl.foR.fo.FoValue;
/**
* A "bookmark-title" object in XSL-FO.
@@ -155,8 +157,8 @@
* Overrides standard logic as text-transform does not apply to a bookmark.
*/
@Override
- public FoValue traitTextTransform(final FoContext context) {
- return FoValue.NONE;
+ public TextTransform traitTextTransform(final FoContext context) {
+ return TextTransform.NONE;
}
/**
@@ -165,8 +167,9 @@
* is always the initial value.
*/
@Override
- public FoValue traitWhiteSpaceTreatment(final FoContext context) {
- return FoValue.IGNORE_IF_SURROUNDING_LINEFEED;
+ public WhiteSpaceTreatment traitWhiteSpaceTreatment(
+ final FoContext context) {
+ return WhiteSpaceTreatment.IGNORE_IF_SURROUNDING_LINEFEED;
}
/**
@@ -175,8 +178,8 @@
* is always the initial value.
*/
@Override
- public FoValue traitLinefeedTreatment(final FoContext context) {
- return FoValue.TREAT_AS_SPACE;
+ public LinefeedTreatment traitLinefeedTreatment(final FoContext context) {
+ return LinefeedTreatment.TREAT_AS_SPACE;
}
/**
Modified: trunk/foray/foray-fotree/src/java/org/foray/fotree/fo/prop/Enumerated.java
===================================================================
--- trunk/foray/foray-fotree/src/java/org/foray/fotree/fo/prop/Enumerated.java 2007-04-13 20:18:09 UTC (rev 9187)
+++ trunk/foray/foray-fotree/src/java/org/foray/fotree/fo/prop/Enumerated.java 2007-04-13 23:58:59 UTC (rev 9188)
@@ -126,7 +126,7 @@
}
case HYPHENATION_KEEP: {
if (parent != null) {
- return parent.traitHyphenationKeep(context);
+ return parent.getPropertyList().traitHyphenationKeep(context);
}
return FoValue.AUTO;
}
@@ -144,19 +144,21 @@
}
case LINEFEED_TREATMENT: {
if (parent != null) {
- return parent.traitLinefeedTreatment(context);
+ return parent.getPropertyList().traitLinefeedTreatment(context);
}
return FoValue.TREAT_AS_SPACE;
}
case LINE_HEIGHT_SHIFT_ADJUSTMENT: {
if (parent != null) {
- return parent.traitLineHeightShiftAdjustment(context);
+ return parent.getPropertyList().traitLineHeightShiftAdjustment(
+ context);
}
return FoValue.CONSIDER_SHIFTS;
}
case LINE_STACKING_STRATEGY: {
if (parent != null) {
- return parent.traitLineStackingStrategy(context);
+ return parent.getPropertyList().traitLineStackingStrategy(
+ context);
}
return FoValue.MAX_HEIGHT;
}
@@ -180,7 +182,8 @@
}
case WHITE_SPACE_TREATMENT: {
if (parent != null) {
- return parent.traitWhiteSpaceTreatment(context);
+ return parent.getPropertyList().traitWhiteSpaceTreatment(
+ context);
}
return FoValue.IGNORE_IF_SURROUNDING_LINEFEED;
}
@@ -192,7 +195,7 @@
}
case EMPTY_CELLS: {
if (parent != null) {
- return parent.traitEmptyCells(context);
+ return parent.getPropertyList().traitEmptyCells(context);
}
return FoValue.SHOW;
}
@@ -204,43 +207,44 @@
}
case REFERENCE_ORIENTATION: {
if (parent != null) {
- return parent.traitReferenceOrientation(context);
+ return parent.getPropertyList().traitReferenceOrientation(
+ context);
}
return FoValue.NUM_ZERO;
}
case SPEAK_HEADER: {
if (parent != null) {
- return parent.traitSpeakHeader(context);
+ return parent.getPropertyList().traitSpeakHeader(context);
}
return FoValue.ONCE;
}
case SPEAK: {
if (parent != null) {
- return parent.traitSpeak(context);
+ return parent.getPropertyList().traitSpeak(context);
}
return FoValue.NORMAL;
}
case SPEAK_NUMERAL: {
if (parent != null) {
- return parent.traitSpeakNumeral(context);
+ return parent.getPropertyList().traitSpeakNumeral(context);
}
return FoValue.CONTINUOUS;
}
case SPEAK_PUNCTUATION: {
if (parent != null) {
- return parent.traitSpeakPunctuation(context);
+ return parent.getPropertyList().traitSpeakPunctuation(context);
}
return FoValue.NONE;
}
case TEXT_TRANSFORM: {
if (parent != null) {
- return parent.traitTextTransform(context);
+ return parent.getPropertyList().traitTextTransform(context);
}
return FoValue.NONE;
}
case VISIBILITY: {
if (parent != null) {
- return parent.traitVisibility(context);
+ return parent.getPropertyList().traitVisibility(context);
}
return FoValue.VISIBLE;
}
@@ -383,7 +387,7 @@
return fobj.getPropertyList().traitFontSelectionStrategy(context);
}
case HYPHENATION_KEEP: {
- return fobj.traitHyphenationKeep(context);
+ return fobj.getPropertyList().traitHyphenationKeep(context);
}
case LEADER_ALIGNMENT: {
return fobj.getPropertyList().getLeaderAlignment(context);
@@ -392,13 +396,14 @@
return fobj.getPropertyList().getLeaderPattern(context);
}
case LINEFEED_TREATMENT: {
- return fobj.traitLinefeedTreatment(context);
+ return fobj.getPropertyList().traitLinefeedTreatment(context);
}
case LINE_HEIGHT_SHIFT_ADJUSTMENT: {
- return fobj.traitLineHeightShiftAdjustment(context);
+ return fobj.getPropertyList().traitLineHeightShiftAdjustment(
+ context);
}
case LINE_STACKING_STRATEGY: {
- return fobj.traitLineStackingStrategy(context);
+ return fobj.getPropertyList().traitLineStackingStrategy(context);
}
case ODD_OR_EVEN: {
return fobj.traitOddOrEven();
@@ -416,7 +421,7 @@
return fobj.getPropertyList().getRelativeAlign(context);
}
case RELATIVE_POSITION: {
- return fobj.traitRelativePosition(context);
+ return fobj.getPropertyList().traitRelativePosition(context);
}
case RULE_STYLE: {
return fobj.getPropertyList().getRuleStyle(context);
@@ -425,34 +430,34 @@
return fobj.getPropertyList().getScaling(context);
}
case SCALING_METHOD: {
- return fobj.traitScalingMethod(context);
+ return fobj.getPropertyList().traitScalingMethod(context);
}
case SPAN: {
return fobj.getPropertyList().getSpan(context);
}
case SUPPRESS_AT_LINE_BREAK: {
- return fobj.traitSuppressAtLineBreak(context);
+ return fobj.getPropertyList().traitSuppressAtLineBreak(context);
}
case UNICODE_BIDI: {
- return fobj.traitUnicodeBidi(context);
+ return fobj.getPropertyList().traitUnicodeBidi(context);
}
case WHITE_SPACE: {
return fobj.getPropertyList().traitWhiteSpace(context);
}
case WHITE_SPACE_TREATMENT: {
- return fobj.traitWhiteSpaceTreatment(context);
+ return fobj.getPropertyList().traitWhiteSpaceTreatment(context);
}
case WRAP_OPTION: {
return fobj.getPropertyList().getWrapOption(context);
}
case CLEAR: {
- return fobj.traitClear(context);
+ return fobj.getPropertyList().traitClear(context);
}
case EMPTY_CELLS: {
- return fobj.traitEmptyCells(context);
+ return fobj.getPropertyList().traitEmptyCells(context);
}
case FLOAT: {
- return fobj.traitFloat(context);
+ return fobj.getPropertyList().traitFloat(context);
}
case PAGE_BREAK_AFTER: {
return fobj.getPropertyList().traitPageBreakAfter(context);
@@ -464,28 +469,28 @@
return fobj.getPropertyList().traitPageBreakInside(context);
}
case REFERENCE_ORIENTATION: {
- return fobj.traitReferenceOrientation(context);
+ return fobj.getPropertyList().traitReferenceOrientation(context);
}
case RENDERING_INTENT: {
- return fobj.traitRenderingIntent(context);
+ return fobj.getPropertyList().traitRenderingIntent(context);
}
case SPEAK_HEADER: {
- return fobj.traitSpeakHeader(context);
+ return fobj.getPropertyList().traitSpeakHeader(context);
}
case SPEAK: {
- return fobj.traitSpeak(context);
+ return fobj.getPropertyList().traitSpeak(context);
}
case SPEAK_NUMERAL: {
- return fobj.traitSpeakNumeral(context);
+ return fobj.getPropertyList().traitSpeakNumeral(context);
}
case SPEAK_PUNCTUATION: {
- return fobj.traitSpeakPunctuation(context);
+ return fobj.getPropertyList().traitSpeakPunctuation(context);
}
case TEXT_TRANSFORM: {
- return fobj.traitTextTransform(context);
+ return fobj.getPropertyList().traitTextTransform(context);
}
case VISIBILITY: {
- return fobj.traitVisibility(context);
+ return fobj.getPropertyList().traitVisibility(context);
}
}
return null;
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
