Merged revisions 647692,647742,647745 via svnmerge from

https://svn.apache.org/repos/asf/xmlgraphics/fop/trunk

................
  r647692 | jeremias | 2008-04-14 09:25:22 +0100 (Mon, 14 Apr 2008) | 3 lines
  
  Initialized merge tracking via "svnmerge" with revisions "1-615152" from 
  https://svn.apache.org/repos/asf/xmlgraphics/fop/branches/Temp_ProcessingFeedback
................
  r647742 | jeremias | 2008-04-14 12:53:29 +0100 (Mon, 14 Apr 2008) | 298 lines
  
  Merged branch
  https://svn.apache.org/repos/asf/xmlgraphics/fop/branches/Temp_ProcessingFeedback
  into Trunk.
  
  Changes on branch:
  ........
    r615153 | jeremias | 2008-01-25 10:07:21 +0100 (Fr, 25 Jan 2008) | 1 line
    
    Created temporary branch for processing feedback.
  ........
    r615155 | jeremias | 2008-01-25 10:11:59 +0100 (Fr, 25 Jan 2008) | 1 line
    
    Initial commit of what I've built already for those who prefer code to minimalistic design docs.
  ........
    r615278 | jeremias | 2008-01-25 18:25:00 +0100 (Fr, 25 Jan 2008) | 1 line
    
    EventProducer interfaces now operational.
  ........
    r615773 | jeremias | 2008-01-28 10:06:16 +0100 (Mo, 28 Jan 2008) | 1 line
    
    No casting in client code when creating EventProducer instances.
  ........
    r616242 | vhennebert | 2008-01-29 11:34:45 +0100 (Di, 29 Jan 2008) | 3 lines
    
    Trick to avoid hard-coding the class name of EventProducer in the source file.
    Feel free to revert if it's not ok.
  ........
    r616900 | jeremias | 2008-01-30 21:59:31 +0100 (Mi, 30 Jan 2008) | 1 line
    
    Generate event model XMLs in to the build directory: build/gensrc and build/test-gensrc (the latter is new and needs to be setup as source folder in your IDE!)
  ........
    r616907 | jeremias | 2008-01-30 22:12:59 +0100 (Mi, 30 Jan 2008) | 1 line
    
    Added an XMLResourceBundle that uses an XML file instead of a properties file to load the translations. The XML format is the same as for Cocoon's XMLResourceBundle.
  ........
    r617097 | vhennebert | 2008-01-31 11:53:21 +0100 (Do, 31 Jan 2008) | 2 lines
    
    Minor typo + slight improvement of Javadoc
  ........
    r617176 | jeremias | 2008-01-31 19:14:19 +0100 (Do, 31 Jan 2008) | 5 lines
    
    Renamed FopEvent to Event as suggested by Simon.
    EventProducerCollectorTask.java now reads the EventSeverity from a doclet tag.
    Added generation of EventProducer translations (including simple merging, no validation, yet)
    EventFormatter introduced (only basic functionality, yet).
    Added a simple EventListener implementation that uses EventFormatter to convert the events to human-readable, localized messages that are sent to the log via Commons Logging.
  ........
    r617362 | jeremias | 2008-02-01 08:18:07 +0100 (Fr, 01 Feb 2008) | 1 line
    
    Some remaining rename operations based on an earlier discussion.
  ........
    r617413 | jeremias | 2008-02-01 10:46:26 +0100 (Fr, 01 Feb 2008) | 2 lines
    
    Extracted formatting functionality into utility class AdvancedMessageFormat.java.
    AdvancedMessageFormat.java now supports conditional sub-groups (delimited by []).
  ........
    r618682 | jeremias | 2008-02-05 17:07:08 +0100 (Di, 05 Feb 2008) | 1 line
    
    Add support for special object formatters (where toString() isn't good enough). ATM, it's hard-coded but could later be hooked into dynamic discovery if we have multiple such formatters. The SAX Locator is the only example for now.
  ........
    r618686 | jeremias | 2008-02-05 17:12:56 +0100 (Di, 05 Feb 2008) | 3 lines
    
    Hooked most of FONode into the new event mechanism. The FOUserAgent provides a DefaultEventBroadcaster instance.
    If a producer method declares throwing an exception, the event is automatically marked FATAL and the dynamic proxy throws an exception right after notifying the listeners.
    The exceptions are created through the EventExceptionManager. It currently contains only one exception factory for ValidationException. If we need more such factories it's better to register them dynamically. Right now, they're hard-coded.
  ........
    r619313 | jeremias | 2008-02-07 10:14:15 +0100 (Do, 07 Feb 2008) | 1 line
    
    Make sure no events are now just silently swallowed because after upgrading a user doesn't know about the event system.
  ........
    r619314 | jeremias | 2008-02-07 10:14:46 +0100 (Do, 07 Feb 2008) | 1 line
    
    Log what translation file is being written.
  ........
    r619320 | jeremias | 2008-02-07 10:31:00 +0100 (Do, 07 Feb 2008) | 2 lines
    
    FObj hooked into the event system.
    Code reduction using a protected method on FONode to acquire a FOValidationEventProducer.
  ........
    r619359 | jeremias | 2008-02-07 11:59:19 +0100 (Do, 07 Feb 2008) | 2 lines
    
    Fop's QName now extends XGCommons' QName to initiate a transition.
    Hooked PropertyList into the event mechanism.
  ........
    r631252 | jeremias | 2008-02-26 16:24:33 +0100 (Di, 26 Feb 2008) | 1 line
    
    Removed superfluous warning.
  ........
    r631268 | jeremias | 2008-02-26 17:08:11 +0100 (Di, 26 Feb 2008) | 1 line
    
    Deprecated two methods which are a problem for localization. Also helps finding additional spots to switch over to the event mechanism.
  ........
    r633852 | jeremias | 2008-03-05 15:20:24 +0100 (Mi, 05 Mrz 2008) | 1 line
    
    Add severity to formatting parameters.
  ........
    r633855 | jeremias | 2008-03-05 15:21:57 +0100 (Mi, 05 Mrz 2008) | 4 lines
    
    Added support for additional field styles:
    {<fieldname>,if,<true-text>,<false-text>}
    {<fieldname>,equals,<test-string>,<true-text>,<false-text>}
  ........
    r633856 | jeremias | 2008-03-05 15:24:04 +0100 (Mi, 05 Mrz 2008) | 2 lines
    
    Javadocs and TODOs.
    EventListeners can change the event severity.
  ........
    r633857 | jeremias | 2008-03-05 15:27:08 +0100 (Mi, 05 Mrz 2008) | 4 lines
    
    Javadocs.
    Moved out event listener registration into a CompositeEventListener.
    Event broadcaster uses the events effective severity, not the initial value (for the case where listeners override the initial value).
    Set up a special EventBroadCaster in the FOUserAgent that filters events through a class (FOValidationEventListenerProxy) that adjusts the event severity for relaxed validation.
  ........
    r633858 | jeremias | 2008-03-05 15:32:07 +0100 (Mi, 05 Mrz 2008) | 2 lines
    
    Instead of always decentrally checking whether strict validation is enabled or not, this is now done in a special event listener. The event producer method caller simply indicates whether it can recover from the error condition and continue.
    Started switching to event production in table FOs.
  ........
    r634027 | jeremias | 2008-03-05 21:58:35 +0100 (Mi, 05 Mrz 2008) | 7 lines
    
    Moved AdvancedMessageFormat into its own package.
    AdvancedMessageFormat got the following added functionality:
    - Alternative conditional regions [ bla {field}] -> [ bla {field1}| even more bla {field2}]
    - Functions: functions get access to the parameters and they can produce an object that is then formatted ({#gatherContextInfo})
    - "if" and "equals" format moved to top-level classes and added by dynamic registration.
    EventFormatter now supports includes in the form {{includeName}} so you can include other entries from the resource bundle for better reuse.
    Some more events in table code.
  ........
    r634031 | jeremias | 2008-03-05 22:05:22 +0100 (Mi, 05 Mrz 2008) | 1 line
    
    SVN Props
  ........
    r634208 | jeremias | 2008-03-06 11:26:52 +0100 (Do, 06 Mrz 2008) | 2 lines
    
    Improved context gathering.
    Moved GatherContextInfoFunction to an inner class of FONode to reduce visibilities.
  ........
    r634209 | jeremias | 2008-03-06 11:28:14 +0100 (Do, 06 Mrz 2008) | 1 line
    
    Made FOPException localizable.
  ........
    r634280 | jeremias | 2008-03-06 15:38:30 +0100 (Do, 06 Mrz 2008) | 2 lines
    
    ExceptionFactory is now dynamically registered.
    More table warnings and errors switch to events.
  ........
    r634326 | jeremias | 2008-03-06 17:08:16 +0100 (Do, 06 Mrz 2008) | 1 line
    
    Remaining table FOs switched to events.
  ........
    r634328 | jeremias | 2008-03-06 17:09:21 +0100 (Do, 06 Mrz 2008) | 1 line
    
    Deprecated FOP's QName. Mixing with Commons' variant only produces problems.
  ........
    r634381 | jeremias | 2008-03-06 20:12:57 +0100 (Do, 06 Mrz 2008) | 2 lines
    
    Made the "invalidChild" event fully localizable by adding a "lookup" field for the optional rule to be displayed.
    And a few switches to the event system.
  ........
    r634692 | jeremias | 2008-03-07 15:31:43 +0100 (Fr, 07 Mrz 2008) | 1 line
    
    More FO tree stuff switched to events.
  ........
    r634712 | jeremias | 2008-03-07 16:19:21 +0100 (Fr, 07 Mrz 2008) | 1 line
    
    Avoid an NPE that says nothing (ex. could happen if the message template is wrong).
  ........
    r634738 | jeremias | 2008-03-07 17:38:21 +0100 (Fr, 07 Mrz 2008) | 2 lines
    
    Non-FO children were not properly run through validation by FOTreeBuilder.
    Unified the way that non-FO elements are validated. Some FOs were already fixed. I now fixed the rest, so foreign elements can occur everywhere.
  ........
    r637833 | jeremias | 2008-03-17 12:01:41 +0100 (Mo, 17 Mrz 2008) | 1 line
    
    Exception while cloning for RetrieveMarker to be handled by user as suggested by Andreas.
  ........
    r637835 | jeremias | 2008-03-17 12:03:31 +0100 (Mo, 17 Mrz 2008) | 1 line
    
    Throw a RuntimeException of no other Exception class is specified for an event as a fallback if someone just sets the event severity to FATAL.
  ........
    r637838 | jeremias | 2008-03-17 12:06:10 +0100 (Mo, 17 Mrz 2008) | 1 line
    
    Throw a meaningful exception when the property name is wrong. Otherwise, there will be an ArrayIndexOutOfBoundsException.
  ........
    r637859 | jeremias | 2008-03-17 13:35:26 +0100 (Mo, 17 Mrz 2008) | 1 line
    
    Throw a meaningful exception when the property name is wrong. Otherwise, there will be an ArrayIndexOutOfBoundsException.
  ........
    r637938 | jeremias | 2008-03-17 16:19:51 +0100 (Mo, 17 Mrz 2008) | 1 line
    
    Switched pagination package to events.
  ........
    r637947 | jeremias | 2008-03-17 16:45:16 +0100 (Mo, 17 Mrz 2008) | 1 line
    
    Removed unlocalizable validation helper methods.
  ........
    r637952 | jeremias | 2008-03-17 16:59:02 +0100 (Mo, 17 Mrz 2008) | 1 line
    
    Events on FOTreeBuilder.
  ........
    r638299 | jeremias | 2008-03-18 11:09:30 +0100 (Di, 18 Mrz 2008) | 2 lines
    
    Added support for java.util.text's ChoiceFormat to AdvancedMessageFormat.
    Reuse the regexes as constants.
  ........
    r638302 | jeremias | 2008-03-18 11:17:06 +0100 (Di, 18 Mrz 2008) | 1 line
    
    Events for inline-level layout managers.
  ........
    r638774 | jeremias | 2008-03-19 11:17:36 +0100 (Mi, 19 Mrz 2008) | 1 line
    
    Added DEBUG level.
  ........
    r638777 | jeremias | 2008-03-19 11:23:40 +0100 (Mi, 19 Mrz 2008) | 3 lines
    
    Generalized FOValidationEventListenerProxy into FOPEventListenerProxy, the main proxy for FOP's own event manipulation proxy. Done because of support for overflow="hidden" vs. overflow="error-if-overflow".
    Switched block-level layout managers to events.
    Some cleanup along the way.
  ........
    r639222 | jeremias | 2008-03-20 10:27:34 +0100 (Do, 20 Mrz 2008) | 2 lines
    
    Some initial work for event forwarding from Batik.
    Missing errors/exceptions converted to events in PageSequenceMaster.
  ........
    r639270 | jeremias | 2008-03-20 13:50:35 +0100 (Do, 20 Mrz 2008) | 1 line
    
    Removed DEBUG event severity again. Promoted constrained geometry adjustment event to INFO level as per discussion.
  ........
    r640395 | jeremias | 2008-03-24 13:39:13 +0100 (Mo, 24 Mrz 2008) | 3 lines
    
    Moved the creation of the fallback LoggingEventListener to FOUserAgent so event before the startDocument() SAX event arrive in the log.
    Dynamic discovery of event models. Renderers and extensions can register renderer-specific event models.
    Switched the most important parts of the renderers to events (maybe not everything is converted).
  ........
    r640397 | jeremias | 2008-03-24 13:43:04 +0100 (Mo, 24 Mrz 2008) | 1 line
    
    Remaining fixcrlfs. Xalan likes to mix CRLF and LF on Windows.
  ........
    r640398 | jeremias | 2008-03-24 13:43:54 +0100 (Mo, 24 Mrz 2008) | 1 line
    
    Ignore namespace declarations for property handling.
  ........
    r640463 | jeremias | 2008-03-24 17:59:52 +0100 (Mo, 24 Mrz 2008) | 2 lines
    
    Event in area package.
    Exposed getUserAgent() in Renderer interface (was already public in AbstractRenderer).
  ........
    r642972 | jeremias | 2008-03-31 14:18:39 +0200 (Mo, 31 Mrz 2008) | 1 line
    
    Code restructured a bit.
  ........
    r642975 | jeremias | 2008-03-31 14:24:07 +0200 (Mo, 31 Mrz 2008) | 2 lines
    
    Plugged fonts package into the event subsystem. Note: I did not follow the same pattern as for the rest as the font package is to be considered FOP-external, so I just added a manual adapter for the FontEventListener. This demonstrates how an external library can be integrated with the event system.
    Missing warning for unknown formatting objects added. Warning is not issued by the ElementMappingRegistry anymore but by FOTreeBuilder which has access to more context information.
  ........
    r642997 | jeremias | 2008-03-31 16:10:08 +0200 (Mo, 31 Mrz 2008) | 1 line
    
    Added an example to demonstrate how to write your own event listener and how to deal with the exceptions thrown in the process.
  ........
    r642998 | jeremias | 2008-03-31 16:13:40 +0200 (Mo, 31 Mrz 2008) | 1 line
    
    Removed unused method. Event formatting should not be part of the Event class. Use EventFormatter.format(Event) instead.
  ........
    r643066 | jeremias | 2008-03-31 19:18:54 +0200 (Mo, 31 Mrz 2008) | 1 line
    
    First part of the event subsystem documentation (DRAFT).
  ........
    r643784 | jeremias | 2008-04-02 10:05:33 +0200 (Mi, 02 Apr 2008) | 1 line
    
    More documentation.
  ........
    r643785 | jeremias | 2008-04-02 10:06:38 +0200 (Mi, 02 Apr 2008) | 1 line
    
    Some nits.
  ........
    r643787 | jeremias | 2008-04-02 10:24:41 +0200 (Mi, 02 Apr 2008) | 1 line
    
    Completed javadocs
  ........
    r643824 | jeremias | 2008-04-02 12:00:30 +0200 (Mi, 02 Apr 2008) | 1 line
    
    Javadocs.
  ........
    r645847 | vhennebert | 2008-04-08 12:54:16 +0200 (Di, 08 Apr 2008) | 2 lines
    
    Minor typo fixes
  ........
    r645848 | vhennebert | 2008-04-08 12:58:30 +0200 (Di, 08 Apr 2008) | 2 lines
    
    Another small typo fix
  ........
    r647678 | jeremias | 2008-04-14 09:20:26 +0200 (Mo, 14 Apr 2008) | 1 line
    
    Renamed *EventProducer.Factory.create() to *EventProducer.Provider.get() to better reflect what the method does (instances may be cached and reused).
  ........
................
  r647745 | jeremias | 2008-04-14 13:01:06 +0100 (Mon, 14 Apr 2008) | 1 line
  
  svnmerge didn't work for me in this case. Remove svn merge info.
................


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

9 files changed, 1403 insertions, 90 deletions

diff --git a/src/java/org/apache/fop/util/QName.java b/src/java/org/apache/fop/util/QName.java
index 390e29dd9..132f5b4dc 100644
--- a/src/java/org/apache/fop/util/QName.java
+++ b/src/java/org/apache/fop/util/QName.java
@@ -19,23 +19,17 @@
 
 package org.apache.fop.util;
 
-import java.io.Serializable;
-
 /**
  * Represents a qualified name of an XML element or an XML attribute.
  * <p>
  * Note: This class allows to carry a namespace prefix but it is not used in the equals() and 
  * hashCode() methods.
+ * @deprecated Use the XML Graphics Commons variant instead!
  */
-public class QName implements Serializable {
+public class QName extends org.apache.xmlgraphics.util.QName {
 
     private static final long serialVersionUID = -5225376740044770690L;
     
-    private String namespaceURI;
-    private String localName;
-    private String prefix;
-    private int hashCode;
-    
     /**
      * Main constructor.
      * @param namespaceURI the namespace URI
@@ -43,16 +37,7 @@ public class QName implements Serializable {
      * @param localName the local name
      */
     public QName(String namespaceURI, String prefix, String localName) {
-        if (localName == null) {
-            throw new NullPointerException("Parameter localName must not be null");
-        }
-        if (localName.length() == 0) {
-            throw new IllegalArgumentException("Parameter localName must not be empty");
-        }
-        this.namespaceURI = namespaceURI;
-        this.prefix = prefix;
-        this.localName = localName;
-        this.hashCode = toHashString().hashCode();
+        super(namespaceURI, prefix, localName);
     }
     
     /**
@@ -61,78 +46,7 @@ public class QName implements Serializable {
      * @param qName the qualified name
      */
     public QName(String namespaceURI, String qName) {
-        if (qName == null) {
-            throw new NullPointerException("Parameter localName must not be null");
-        }
-        if (qName.length() == 0) {
-            throw new IllegalArgumentException("Parameter localName must not be empty");
-        }
-        this.namespaceURI = namespaceURI;
-        int p = qName.indexOf(':');
-        if (p > 0) {
-            this.prefix = qName.substring(0, p);
-            this.localName = qName.substring(p + 1);
-        } else {
-            this.prefix = null;
-            this.localName = qName;
-        }
-        this.hashCode = toHashString().hashCode();
+        super(namespaceURI, qName);
     }
     
-    /** @return the namespace URI */
-    public String getNamespaceURI() {
-        return this.namespaceURI;
-    }
-    
-    /** @return the namespace prefix */
-    public String getPrefix() {
-        return this.prefix;
-    }
-    
-    /** @return the local name */
-    public String getLocalName() {
-        return this.localName;
-    }
-    
-    /** @return the fully qualified name */
-    public String getQName() {
-        return getPrefix() != null ? getPrefix() + ':' + getLocalName() : getLocalName();
-    }
-
-    /** {@inheritDoc} */
-    public int hashCode() {
-        return this.hashCode;
-    }
-
-    /** {@inheritDoc} */
-    public boolean equals(Object obj) {
-        if (obj == null) {
-            return false;
-        } else if (obj == this) {
-            return true;
-        } else {
-            if (obj instanceof QName) {
-                QName other = (QName)obj;
-                if ((getNamespaceURI() == null && other.getNamespaceURI() == null)
-                        || getNamespaceURI().equals(other.getNamespaceURI())) {
-                    return getLocalName().equals(other.getLocalName());
-                }
-            }
-        }
-        return false;
-    }
-
-    /** {@inheritDoc} */
-    public String toString() {
-        return prefix != null
-                ? (prefix + ":" + localName)
-                : toHashString();
-    }
-
-    private String toHashString() {
-        return (namespaceURI != null 
-                ? ("{" + namespaceURI + "}" + localName) 
-                : localName);
-    }
-
 }
diff --git a/src/java/org/apache/fop/util/XMLResourceBundle.java b/src/java/org/apache/fop/util/XMLResourceBundle.java
new file mode 100644
index 000000000..1b320816b
--- /dev/null
+++ b/src/java/org/apache/fop/util/XMLResourceBundle.java
@@ -0,0 +1,398 @@
+/* 
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/* $Id$ */
+
+package org.apache.fop.util;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+import java.util.Enumeration;
+import java.util.Hashtable;
+import java.util.Locale;
+import java.util.Map;
+import java.util.MissingResourceException;
+import java.util.Properties;
+import java.util.ResourceBundle;
+import java.util.Stack;
+
+import javax.xml.transform.Transformer;
+import javax.xml.transform.TransformerException;
+import javax.xml.transform.sax.SAXResult;
+import javax.xml.transform.sax.SAXTransformerFactory;
+import javax.xml.transform.stream.StreamSource;
+
+import org.xml.sax.Attributes;
+import org.xml.sax.SAXException;
+import org.xml.sax.helpers.DefaultHandler;
+
+import org.apache.xmlgraphics.util.QName;
+
+/**
+ * This class is a ResourceBundle that loads its contents from XML files instead of properties
+ * files (like PropertiesResourceBundle).
+ * <p>
+ * The XML format for this resource bundle implementation is the following
+ * (the same as Apache Cocoon's XMLResourceBundle):
+ * <pre>
+ * &lt;catalogue xml:lang="en"&gt;
+ *   &lt;message key="key1"&gt;Message &lt;br/&gt; Value 1&lt;/message&gt;
+ *   &lt;message key="key2"&gt;Message &lt;br/&gt; Value 1&lt;/message&gt;
+ *   ...
+ * &lt;/catalogue&gt;
+ * </pre>
+ */
+public class XMLResourceBundle extends ResourceBundle {
+
+    //Note: Some code here has been copied and adapted from Apache Harmony!
+    
+    private Properties resources = new Properties();
+
+    private Locale locale;
+    
+    private static SAXTransformerFactory tFactory 
+        = (SAXTransformerFactory)SAXTransformerFactory.newInstance();
+
+    /**
+     * Creates a resource bundle from an InputStream.
+     * @param in the stream to read from
+     * @throws IOException if an I/O error occurs
+     */
+    public XMLResourceBundle(InputStream in) throws IOException {
+        try {
+            Transformer transformer = tFactory.newTransformer();
+            StreamSource src = new StreamSource(in);
+            SAXResult res = new SAXResult(new CatalogueHandler());
+            transformer.transform(src, res);
+        } catch (TransformerException e) {
+            throw new IOException("Error while parsing XML resource bundle: " + e.getMessage());
+        }
+    }
+    
+    /**
+     * Gets a resource bundle using the specified base name, default locale, and class loader.
+     * @param baseName the base name of the resource bundle, a fully qualified class name
+     * @param loader the class loader from which to load the resource bundle
+     * @return a resource bundle for the given base name and the default locale
+     * @throws MissingResourceException if no resource bundle for the specified base name can be
+     *                                          found
+     * @see java.util.ResourceBundle#getBundle(String)
+     */
+    public static ResourceBundle getXMLBundle(String baseName, ClassLoader loader)
+                throws MissingResourceException {
+        return getXMLBundle(baseName, Locale.getDefault(), loader);
+    }
+    
+    /**
+     * Gets a resource bundle using the specified base name, locale, and class loader.
+     * @param baseName the base name of the resource bundle, a fully qualified class name
+     * @param locale the locale for which a resource bundle is desired
+     * @param loader the class loader from which to load the resource bundle
+     * @return a resource bundle for the given base name and locale
+     * @throws MissingResourceException if no resource bundle for the specified base name can be
+     *                                          found
+     * @see java.util.ResourceBundle#getBundle(String, Locale, ClassLoader)
+     */
+    public static ResourceBundle getXMLBundle(String baseName, Locale locale, ClassLoader loader)
+                throws MissingResourceException {
+        if (loader == null) {
+            throw new NullPointerException("loader must not be null");
+        }
+        if (baseName == null) {
+            throw new NullPointerException("baseName must not be null");
+        }
+            
+        ResourceBundle bundle;
+        if (!locale.equals(Locale.getDefault())) {
+            bundle = handleGetXMLBundle(baseName, "_" + locale, false, loader);
+            if (bundle != null) {
+                return bundle;
+            }
+        }
+        bundle = handleGetXMLBundle(baseName, "_" + Locale.getDefault(), true, loader);
+        if (bundle != null) {
+            return bundle;
+        }
+        throw new MissingResourceException(
+                baseName + " (" + locale + ")", baseName + '_' + locale, null);
+    }
+
+    static class MissingBundle extends ResourceBundle {
+        public Enumeration getKeys() {
+            return null;
+        }
+
+        public Object handleGetObject(String name) {
+            return null;
+        }
+    }
+
+    private static final ResourceBundle MISSING = new MissingBundle();
+    private static final ResourceBundle MISSINGBASE = new MissingBundle();
+    
+    private static Map cache = new java.util.WeakHashMap();
+    //<Object, Hashtable<String, ResourceBundle>>
+    
+    private static ResourceBundle handleGetXMLBundle(String base, String locale,
+            boolean loadBase, final ClassLoader loader) {
+        XMLResourceBundle bundle = null;
+        String bundleName = base + locale;
+        Object cacheKey = loader != null ? (Object) loader : (Object) "null";
+        Hashtable loaderCache; //<String, ResourceBundle>
+        synchronized (cache) {
+            loaderCache = (Hashtable)cache.get(cacheKey);
+            if (loaderCache == null) {
+                loaderCache = new Hashtable();
+                cache.put(cacheKey, loaderCache);
+            }
+        }
+        ResourceBundle result = (ResourceBundle)loaderCache.get(bundleName);
+        if (result != null) {
+            if (result == MISSINGBASE) {
+                return null;
+            }
+            if (result == MISSING) {
+                if (!loadBase) {
+                    return null;
+                }
+                String extension = strip(locale);
+                if (extension == null) {
+                    return null;
+                }
+                return handleGetXMLBundle(base, extension, loadBase, loader);
+            }
+            return result;
+        }
+
+        final String fileName = bundleName.replace('.', '/') + ".xml";
+        InputStream stream = (InputStream)AccessController
+                .doPrivileged(new PrivilegedAction() {
+                    public Object run() {
+                        return loader == null
+                            ? ClassLoader.getSystemResourceAsStream(fileName)
+                            : loader.getResourceAsStream(fileName);
+                    }
+                });
+        if (stream != null) {
+            try {
+                try {
+                    bundle = new XMLResourceBundle(stream);
+                } finally {
+                    stream.close();
+                }
+                bundle.setLocale(locale);
+            } catch (IOException e) {
+                throw new MissingResourceException(e.getMessage(), base, null);
+            }
+        }
+
+        String extension = strip(locale);
+        if (bundle != null) {
+            if (extension != null) {
+                ResourceBundle parent = handleGetXMLBundle(base, extension, true,
+                        loader);
+                if (parent != null) {
+                    bundle.setParent(parent);
+                }
+            }
+            loaderCache.put(bundleName, bundle);
+            return bundle;
+        }
+
+        if (extension != null) {
+            ResourceBundle fallback = handleGetXMLBundle(base, extension, loadBase, loader);
+            if (fallback != null) {
+                loaderCache.put(bundleName, fallback);
+                return fallback;
+            }
+        }
+        loaderCache.put(bundleName, loadBase ? MISSINGBASE : MISSING);
+        return null;
+    }    
+    
+    private void setLocale(String name) {
+        String language = "", country = "", variant = "";
+        if (name.length() > 1) {
+            int nextIndex = name.indexOf('_', 1);
+            if (nextIndex == -1) {
+                nextIndex = name.length();
+            }
+            language = name.substring(1, nextIndex);
+            if (nextIndex + 1 < name.length()) {
+                int index = nextIndex;
+                nextIndex = name.indexOf('_', nextIndex + 1);
+                if (nextIndex == -1) {
+                    nextIndex = name.length();
+                }
+                country = name.substring(index + 1, nextIndex);
+                if (nextIndex + 1 < name.length()) {
+                    variant = name.substring(nextIndex + 1, name.length());
+                }
+            }
+        }
+        this.locale = new Locale(language, country, variant);
+    }
+    
+    private static String strip(String name) {
+        int index = name.lastIndexOf('_');
+        if (index != -1) {
+            return name.substring(0, index);
+        }
+        return null;
+    }
+    
+    private Enumeration getLocalKeys() {
+        return (Enumeration)resources.propertyNames();
+    }
+    
+    /** {@inheritDoc} */
+    public Locale getLocale() {
+        return this.locale;
+    }
+    
+    /** {@inheritDoc} */
+    public Enumeration getKeys() {
+        if (parent == null) {
+            return getLocalKeys();
+        }
+        return new Enumeration() {
+            private Enumeration local = getLocalKeys();
+            private Enumeration pEnum = parent.getKeys();
+
+            private Object nextElement;
+
+            private boolean findNext() {
+                if (nextElement != null) {
+                    return true;
+                }
+                while (pEnum.hasMoreElements()) {
+                    Object next = pEnum.nextElement();
+                    if (!resources.containsKey(next)) {
+                        nextElement = next;
+                        return true;
+                    }
+                }
+                return false;
+            }
+
+            public boolean hasMoreElements() {
+                if (local.hasMoreElements()) {
+                    return true;
+                }
+                return findNext();
+            }
+
+            public Object nextElement() {
+                if (local.hasMoreElements()) {
+                    return local.nextElement();
+                }
+                if (findNext()) {
+                    Object result = nextElement;
+                    nextElement = null;
+                    return result;
+                }
+                // Cause an exception
+                return pEnum.nextElement();
+            }
+        };
+    }
+
+    /** {@inheritDoc} */
+    protected Object handleGetObject(String key) {
+        if (key == null) {
+            throw new NullPointerException("key must not be null");
+        }
+        return resources.get(key);
+    }
+
+    /** {@inheritDoc} */
+    public String toString() {
+        return "XMLResourceBundle: " + getLocale();
+    }
+
+    private class CatalogueHandler extends DefaultHandler {
+        
+        private static final String CATALOGUE = "catalogue";
+        private static final String MESSAGE = "message";
+        
+        private StringBuffer valueBuffer = new StringBuffer();
+        private Stack elementStack = new Stack();
+        private String currentKey = null;
+
+        private boolean isOwnNamespace(String uri) {
+            return ("".equals(uri));
+        }
+        
+        private QName getParentElementName() {
+            return (QName)elementStack.peek();
+        }
+        
+        /** {@inheritDoc} */
+        public void startElement(String uri, String localName, String qName, 
+                Attributes atts) throws SAXException {
+            super.startElement(uri, localName, qName, atts);
+            QName elementName = new QName(uri, qName);
+            if (isOwnNamespace(uri)) {
+                if (CATALOGUE.equals(localName)) {
+                    //nop
+                } else if (MESSAGE.equals(localName)) {
+                    if (!CATALOGUE.equals(getParentElementName().getLocalName())) {
+                        throw new SAXException(MESSAGE + " must be a child of " + CATALOGUE);
+                    }
+                    this.currentKey = atts.getValue("key");
+                } else {
+                    throw new SAXException("Invalid element name: " + elementName);
+                }
+            } else {
+                //ignore
+            }
+            this.valueBuffer.setLength(0);
+            elementStack.push(elementName);
+        }
+
+        /** {@inheritDoc} */
+        public void endElement(String uri, String localName, String qName) throws SAXException {
+            super.endElement(uri, localName, qName);
+            elementStack.pop();
+            if (isOwnNamespace(uri)) {
+                if (CATALOGUE.equals(localName)) {
+                    //nop
+                } else if (MESSAGE.equals(localName)) {
+                    if (this.currentKey == null) {
+                        throw new SAXException(
+                                "current key is null (attribute 'key' might be mistyped)");
+                    }
+                    resources.put(this.currentKey, this.valueBuffer.toString());
+                    this.currentKey = null;
+                }
+            } else {
+                //ignore
+            }
+            this.valueBuffer.setLength(0);
+        }
+        
+        /** {@inheritDoc} */
+        public void characters(char[] ch, int start, int length) throws SAXException {
+            super.characters(ch, start, length);
+            valueBuffer.append(ch, start, length);
+        }
+        
+    }
+    
+}
diff --git a/src/java/org/apache/fop/util/text/AdvancedMessageFormat.java b/src/java/org/apache/fop/util/text/AdvancedMessageFormat.java
new file mode 100644
index 000000000..a2169156a
--- /dev/null
+++ b/src/java/org/apache/fop/util/text/AdvancedMessageFormat.java
@@ -0,0 +1,487 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/* $Id$ */
+
+package org.apache.fop.util.text;
+
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.regex.Pattern;
+
+import org.apache.xmlgraphics.util.Service;
+
+
+/**
+ * Formats messages based on a template and with a set of named parameters. This is similar to
+ * {@link java.util.MessageFormat} but uses named parameters and supports conditional sub-groups.
+ * <p>
+ * Example:
+ * </p>
+ * <p><code>Missing field "{fieldName}"[ at location: {location}]!</code></p>
+ * <ul>
+ *   <li>Curly brackets ("{}") are used for fields.</li>
+ *   <li>Square brackets ("[]") are used to delimit conditional sub-groups. A sub-group is
+ *     conditional when all fields inside the sub-group have a null value. In the case, everything
+ *     between the brackets is skipped.</li>
+ * </ul>
+ */
+public class AdvancedMessageFormat {
+
+    /** Regex that matches "," but not "\," (escaped comma) */
+    static final Pattern COMMA_SEPARATOR_REGEX = Pattern.compile("(?<!\\\\),");
+    
+    private static final Map PART_FACTORIES = new java.util.HashMap();
+    private static final List OBJECT_FORMATTERS = new java.util.ArrayList();
+    private static final Map FUNCTIONS = new java.util.HashMap();
+    
+    private CompositePart rootPart;
+    
+    static {
+        Iterator iter;
+        iter = Service.providers(PartFactory.class, true);
+        while (iter.hasNext()) {
+            PartFactory factory = (PartFactory)iter.next();
+            PART_FACTORIES.put(factory.getFormat(), factory);
+        }
+        iter = Service.providers(ObjectFormatter.class, true);
+        while (iter.hasNext()) {
+            OBJECT_FORMATTERS.add((ObjectFormatter)iter.next());
+        }
+        iter = Service.providers(Function.class, true);
+        while (iter.hasNext()) {
+            Function function = (Function)iter.next();
+            FUNCTIONS.put(function.getName(), function);
+        }
+    }
+    
+    /**
+     * Construct a new message format.
+     * @param pattern the message format pattern.
+     */
+    public AdvancedMessageFormat(CharSequence pattern) {
+        parsePattern(pattern);
+    }
+    
+    private void parsePattern(CharSequence pattern) {
+        rootPart = new CompositePart(false);
+        StringBuffer sb = new StringBuffer();
+        parseInnerPattern(pattern, rootPart, sb, 0);
+    }
+    
+    private int parseInnerPattern(CharSequence pattern, CompositePart parent,
+            StringBuffer sb, int start) {
+        assert sb.length() == 0;
+        int i = start;
+        int len = pattern.length();
+        loop:
+        while (i < len) {
+            char ch = pattern.charAt(i);
+            switch (ch) {
+            case '{':
+                if (sb.length() > 0) {
+                    parent.addChild(new TextPart(sb.toString()));
+                    sb.setLength(0);
+                }
+                i++;
+                int nesting = 1;
+                while (i < len) {
+                    ch = pattern.charAt(i);
+                    if (ch == '{') {
+                        nesting++;
+                    } else if (ch == '}') {
+                        nesting--;
+                        if (nesting == 0) {
+                            i++;
+                            break;
+                        }
+                    }
+                    sb.append(ch);
+                    i++;
+                }
+                parent.addChild(parseField(sb.toString()));
+                sb.setLength(0);
+                break;
+            case ']':
+                i++;
+                break loop; //Current composite is finished
+            case '[':
+                if (sb.length() > 0) {
+                    parent.addChild(new TextPart(sb.toString()));
+                    sb.setLength(0);
+                }
+                i++;
+                CompositePart composite = new CompositePart(true);
+                parent.addChild(composite);
+                i += parseInnerPattern(pattern, composite, sb, i);
+                break;
+            case '|':
+                if (sb.length() > 0) {
+                    parent.addChild(new TextPart(sb.toString()));
+                    sb.setLength(0);
+                }
+                parent.newSection();
+                i++;
+                break;
+            case '\\':
+                if (i < len - 1) {
+                    i++;
+                    ch = pattern.charAt(i);
+                }
+                //no break here! Must be right before "default" section
+            default:
+                sb.append(ch);
+                i++;
+            }
+        }
+        if (sb.length() > 0) {
+            parent.addChild(new TextPart(sb.toString()));
+            sb.setLength(0);
+        }
+        return i - start;
+    }
+    
+    private Part parseField(String field) {
+        String[] parts = COMMA_SEPARATOR_REGEX.split(field, 3);
+        String fieldName = parts[0];
+        if (parts.length == 1) {
+            if (fieldName.startsWith("#")) {
+                return new FunctionPart(fieldName.substring(1));
+            } else {
+                return new SimpleFieldPart(fieldName);
+            }
+        } else {
+            String format = parts[1];
+            PartFactory factory = (PartFactory)PART_FACTORIES.get(format);
+            if (factory == null) {
+                throw new IllegalArgumentException(
+                        "No PartFactory available under the name: " + format);
+            }
+            if (parts.length == 2) {
+                return factory.newPart(fieldName, null);
+            } else {
+                return factory.newPart(fieldName, parts[2]);
+            }
+        }
+    }
+
+    private static Function getFunction(String functionName) {
+        return (Function)FUNCTIONS.get(functionName);
+    }
+
+    /**
+     * Formats a message with the given parameters.
+     * @param params a Map of named parameters (Contents: <String, Object>)
+     * @return the formatted message
+     */
+    public String format(Map params) {
+        StringBuffer sb = new StringBuffer();
+        format(params, sb);
+        return sb.toString();
+    }
+
+    /**
+     * Formats a message with the given parameters.
+     * @param params a Map of named parameters (Contents: <String, Object>)
+     * @param target the target StringBuffer to write the formatted message to
+     */
+    public void format(Map params, StringBuffer target) {
+        rootPart.write(target, params);
+    }
+    
+    /**
+     * Represents a message template part. This interface is implemented by various variants of
+     * the single curly braces pattern ({field}, {field,if,yes,no} etc.).
+     */
+    public interface Part {
+        
+        /**
+         * Writes the formatted part to a string buffer.
+         * @param sb the target string buffer
+         * @param params the parameters to work with
+         */
+        void write(StringBuffer sb, Map params);
+        
+        /**
+         * Indicates whether there is any content that is generated by this message part.
+         * @param params the parameters to work with
+         * @return true if the part has content
+         */
+        boolean isGenerated(Map params);
+    }
+    
+    /**
+     * Implementations of this interface parse a field part and return message parts.
+     */
+    public interface PartFactory {
+        
+        /**
+         * Creates a new part by parsing the values parameter to configure the part.
+         * @param fieldName the field name
+         * @param values the unparsed parameter values
+         * @return the new message part
+         */
+        Part newPart(String fieldName, String values);
+        
+        /**
+         * Returns the name of the message part format.
+         * @return the name of the message part format
+         */
+        String getFormat();
+    }
+    
+    /**
+     * Implementations of this interface format certain objects to strings.
+     */
+    public interface ObjectFormatter {
+        
+        /**
+         * Formats an object to a string and writes the result to a string buffer.
+         * @param sb the target string buffer
+         * @param obj the object to be formatted
+         */
+        void format(StringBuffer sb, Object obj);
+        
+        /**
+         * Indicates whether a given object is supported.
+         * @param obj the object
+         * @return true if the object is supported by the formatter
+         */
+        boolean supportsObject(Object obj);
+    }
+    
+    /**
+     * Implementations of this interface do some computation based on the message parameters
+     * given to it. Note: at the moment, this has to be done in a local-independent way since
+     * there is no locale information.
+     */
+    public interface Function {
+        
+        /**
+         * Executes the function.
+         * @param params the message parameters
+         * @return the function result
+         */
+        Object evaluate(Map params);
+        
+        /**
+         * Returns the name of the function.
+         * @return the name of the function
+         */
+        Object getName();
+    }
+    
+    private static class TextPart implements Part {
+        
+        private String text;
+        
+        public TextPart(String text) {
+            this.text = text;
+        }
+        
+        public void write(StringBuffer sb, Map params) {
+            sb.append(text);
+        }
+        
+        public boolean isGenerated(Map params) {
+            return true;
+        }
+
+        /** {@inheritDoc} */
+        public String toString() {
+            return this.text;
+        }
+    }
+    
+    private static class SimpleFieldPart implements Part {
+        
+        private String fieldName;
+        
+        public SimpleFieldPart(String fieldName) {
+            this.fieldName = fieldName;
+        }
+        
+        public void write(StringBuffer sb, Map params) {
+            if (!params.containsKey(fieldName)) {
+                throw new IllegalArgumentException(
+                        "Message pattern contains unsupported field name: " + fieldName);
+            }
+            Object obj = params.get(fieldName);
+            formatObject(obj, sb);
+        }
+
+        public boolean isGenerated(Map params) {
+            Object obj = params.get(fieldName);
+            return obj != null;
+        }
+        
+        /** {@inheritDoc} */
+        public String toString() {
+            return "{" + this.fieldName + "}";
+        }
+    }
+    
+    /**
+     * Formats an object to a string and writes the result to a string buffer. This method
+     * usually uses the object's <code>toString()</code> method unless there is an
+     * {@link ObjectFormatter} that supports the object. {@link ObjectFormatter}s are registered
+     * through the service provider mechanism defined by the JAR specification.
+     * @param obj the object to be formatted
+     * @param target the target string buffer
+     */
+    public static void formatObject(Object obj, StringBuffer target) {
+        if (obj instanceof String) {
+            target.append(obj);
+        } else {
+            boolean handled = false;
+            Iterator iter = OBJECT_FORMATTERS.iterator();
+            while (iter.hasNext()) {
+                ObjectFormatter formatter = (ObjectFormatter)iter.next();
+                if (formatter.supportsObject(obj)) {
+                    formatter.format(target, obj);
+                    handled = true;
+                    break;
+                }
+            }
+            if (!handled) {
+                target.append(String.valueOf(obj));
+            }
+        }
+    }
+    
+    private static class FunctionPart implements Part {
+        
+        private Function function;
+        
+        public FunctionPart(String functionName) {
+            this.function = getFunction(functionName);
+            if (this.function == null) {
+                throw new IllegalArgumentException("Unknown function: " + functionName);
+            }
+        }
+        
+        public void write(StringBuffer sb, Map params) {
+            Object obj = this.function.evaluate(params);
+            formatObject(obj, sb);
+        }
+
+        public boolean isGenerated(Map params) {
+            Object obj = this.function.evaluate(params);
+            return obj != null;
+        }
+        
+        /** {@inheritDoc} */
+        public String toString() {
+            return "{#" + this.function.getName() + "}";
+        }
+    }
+    
+    private static class CompositePart implements Part {
+        
+        protected List parts = new java.util.ArrayList();
+        private boolean conditional;
+        private boolean hasSections = false;
+        
+        public CompositePart(boolean conditional) {
+            this.conditional = conditional;
+        }
+        
+        private CompositePart(List parts) {
+            this.parts.addAll(parts);
+            this.conditional = true;
+        }
+        
+        public void addChild(Part part) {
+            if (part == null) {
+                throw new NullPointerException("part must not be null");
+            }
+            if (hasSections) {
+                CompositePart composite = (CompositePart)this.parts.get(this.parts.size() - 1);
+                composite.addChild(part);
+            } else {
+                this.parts.add(part);
+            }
+        }
+        
+        public void newSection() {
+            if (!hasSections) {
+                List p = this.parts;
+                //Dropping into a different mode...
+                this.parts = new java.util.ArrayList();
+                this.parts.add(new CompositePart(p));
+                hasSections = true;
+            }
+            this.parts.add(new CompositePart(true));
+        }
+        
+        public void write(StringBuffer sb, Map params) {
+            if (hasSections) {
+                Iterator iter = this.parts.iterator();
+                while (iter.hasNext()) {
+                    CompositePart part = (CompositePart)iter.next();
+                    if (part.isGenerated(params)) {
+                        part.write(sb, params);
+                        break;
+                    }
+                }
+            } else {
+                if (isGenerated(params)) {
+                    Iterator iter = this.parts.iterator();
+                    while (iter.hasNext()) {
+                        Part part = (Part)iter.next();
+                        part.write(sb, params);
+                    }
+                }
+            }
+        }
+
+        public boolean isGenerated(Map params) {
+            if (hasSections) {
+                Iterator iter = this.parts.iterator();
+                while (iter.hasNext()) {
+                    Part part = (Part)iter.next();
+                    if (part.isGenerated(params)) {
+                        return true;
+                    }
+                }
+                return false;
+            } else {
+                if (conditional) {
+                    Iterator iter = this.parts.iterator();
+                    while (iter.hasNext()) {
+                        Part part = (Part)iter.next();
+                        if (!part.isGenerated(params)) {
+                            return false;
+                        }
+                    }
+                }
+                return true;
+            }
+        }
+        
+        /** {@inheritDoc} */
+        public String toString() {
+            return this.parts.toString();
+        }
+    }
+    
+    
+    static String unescapeComma(String string) {
+        return string.replaceAll("\\\\,", ",");
+    }
+}
diff --git a/src/java/org/apache/fop/util/text/ChoiceFieldPart.java b/src/java/org/apache/fop/util/text/ChoiceFieldPart.java
new file mode 100644
index 000000000..df457a02b
--- /dev/null
+++ b/src/java/org/apache/fop/util/text/ChoiceFieldPart.java
@@ -0,0 +1,91 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/* $Id$ */
+
+package org.apache.fop.util.text;
+
+import java.text.ChoiceFormat;
+import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import org.apache.fop.util.text.AdvancedMessageFormat.Part;
+import org.apache.fop.util.text.AdvancedMessageFormat.PartFactory;
+
+/**
+ * Defines a "choice" field part that works like {@link ChoiceFormat}.
+ */
+public class ChoiceFieldPart implements Part {
+    
+    private static final Pattern VARIABLE_REGEX = Pattern.compile("\\{([^\\}]+)\\}");
+    
+    private String fieldName;
+    private ChoiceFormat choiceFormat;
+    
+    /**
+     * Creates a new choice part.
+     * @param fieldName the field name to work on
+     * @param choicesPattern the choices pattern (as used by {@link ChoiceFormat})
+     */
+    public ChoiceFieldPart(String fieldName, String choicesPattern) {
+        this.fieldName = fieldName;
+        this.choiceFormat = new ChoiceFormat(choicesPattern);
+    }
+
+    /** {@inheritDoc} */
+    public boolean isGenerated(Map params) {
+        Object obj = params.get(fieldName);
+        return obj != null;
+    }
+
+    /** {@inheritDoc} */
+    public void write(StringBuffer sb, Map params) {
+        Object obj = params.get(fieldName);
+        Number num = (Number)obj;
+        String result = this.choiceFormat.format(num.doubleValue());
+        Matcher m = VARIABLE_REGEX.matcher(result);
+        if (m.find()) {
+            //Resolve inner variables
+            AdvancedMessageFormat f = new AdvancedMessageFormat(result);
+            f.format(params, sb);
+        } else {
+            sb.append(result);
+        }
+    }
+
+    /** {@inheritDoc} */
+    public String toString() {
+        return "{" + this.fieldName + ",choice, ....}";
+    }
+    
+    /** Factory for ChoiceFieldPart. */
+    public static class Factory implements PartFactory {
+
+        /** {@inheritDoc} */
+        public Part newPart(String fieldName, String values) {
+            return new ChoiceFieldPart(fieldName, values);
+        }
+
+        /** {@inheritDoc} */
+        public String getFormat() {
+            return "choice";
+        }
+        
+    }
+
+}
\ No newline at end of file
diff --git a/src/java/org/apache/fop/util/text/EqualsFieldPart.java b/src/java/org/apache/fop/util/text/EqualsFieldPart.java
new file mode 100644
index 000000000..2114b0d00
--- /dev/null
+++ b/src/java/org/apache/fop/util/text/EqualsFieldPart.java
@@ -0,0 +1,92 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/* $Id$ */
+
+package org.apache.fop.util.text;
+
+import java.util.Map;
+
+import org.apache.fop.util.text.AdvancedMessageFormat.Part;
+import org.apache.fop.util.text.AdvancedMessageFormat.PartFactory;
+
+/**
+ * Defines an "equals" field part that can compare a field's string value against another string.
+ * It returns either of two possible values attached as additional part parameters. Example:
+ * <code>{field,equals,new,This is new!,This is old!}</code>
+ */
+public class EqualsFieldPart extends IfFieldPart {
+    
+    private String equalsValue;
+    
+    /**
+     * Creates a new "equals" field part.
+     * @param fieldName the field name
+     * @param values the unparsed parameter values
+     */
+    public EqualsFieldPart(String fieldName, String values) {
+        super(fieldName, values);
+    }
+
+    /** {@inheritDoc} */
+    protected void parseValues(String values) {
+        String[] parts = AdvancedMessageFormat.COMMA_SEPARATOR_REGEX.split(values, 3);
+        this.equalsValue = parts[0];
+        if (parts.length == 1) {
+            throw new IllegalArgumentException(
+                    "'equals' format must have at least 2 parameters");
+        }
+        if (parts.length == 3) {
+            ifValue = AdvancedMessageFormat.unescapeComma(parts[1]);
+            elseValue = AdvancedMessageFormat.unescapeComma(parts[2]);
+        } else {
+            ifValue = AdvancedMessageFormat.unescapeComma(parts[1]);
+        }
+    }
+    
+    /** {@inheritDoc} */
+    protected boolean isTrue(Map params) {
+        Object obj = params.get(fieldName);
+        if (obj != null) {
+            return String.valueOf(obj).equals(this.equalsValue);
+        } else {
+            return false;
+        }
+    }
+
+    /** {@inheritDoc} */
+    public String toString() {
+        return "{" + this.fieldName + ", equals " + this.equalsValue + "}";
+    }
+    
+    /**
+     * Part factory for "equals".
+     */
+    public static class Factory implements PartFactory {
+
+        /** {@inheritDoc} */
+        public Part newPart(String fieldName, String values) {
+            return new EqualsFieldPart(fieldName, values);
+        }
+
+        /** {@inheritDoc} */
+        public String getFormat() {
+            return "equals";
+        }
+        
+    }
+}
\ No newline at end of file
diff --git a/src/java/org/apache/fop/util/text/GlyphNameFieldPart.java b/src/java/org/apache/fop/util/text/GlyphNameFieldPart.java
new file mode 100644
index 000000000..5d78cdfad
--- /dev/null
+++ b/src/java/org/apache/fop/util/text/GlyphNameFieldPart.java
@@ -0,0 +1,89 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/* $Id$ */
+
+package org.apache.fop.util.text;
+
+import java.util.Map;
+
+import org.apache.xmlgraphics.fonts.Glyphs;
+
+import org.apache.fop.util.text.AdvancedMessageFormat.Part;
+import org.apache.fop.util.text.AdvancedMessageFormat.PartFactory;
+
+/**
+ * Function formatting a character to a glyph name.
+ */
+public class GlyphNameFieldPart implements Part {
+
+    private String fieldName;
+    
+    /**
+     * Creates a new glyph name field part
+     * @param fieldName the field name
+     */
+    public GlyphNameFieldPart(String fieldName) {
+        this.fieldName = fieldName;
+    }
+    
+    /** {@inheritDoc} */
+    public boolean isGenerated(Map params) {
+        Object obj = params.get(fieldName);
+        return obj != null && getGlyphName(obj).length() > 0;
+    }
+    
+    private String getGlyphName(Object obj) {
+        if (obj instanceof Character) {
+            return Glyphs.charToGlyphName(((Character)obj).charValue());
+        } else {
+            throw new IllegalArgumentException(
+                    "Value for glyph name part must be a Character but was: "
+                        + obj.getClass().getName());
+        }
+    }
+
+    /** {@inheritDoc} */
+    public void write(StringBuffer sb, Map params) {
+        if (!params.containsKey(fieldName)) {
+            throw new IllegalArgumentException(
+                    "Message pattern contains unsupported field name: " + fieldName);
+        }
+        Object obj = params.get(fieldName);
+        sb.append(getGlyphName(obj));
+    }
+
+    /** {@inheritDoc} */
+    public String toString() {
+        return "{" + this.fieldName + ",glyph-name}";
+    }
+    
+    /** Factory for {@link GlyphNameFieldPart}. */
+    public static class Factory implements PartFactory {
+
+        /** {@inheritDoc} */
+        public Part newPart(String fieldName, String values) {
+            return new GlyphNameFieldPart(fieldName);
+        }
+        
+        /** {@inheritDoc} */
+        public String getFormat() {
+            return "glyph-name";
+        }
+        
+    }
+}
diff --git a/src/java/org/apache/fop/util/text/HexFieldPart.java b/src/java/org/apache/fop/util/text/HexFieldPart.java
new file mode 100644
index 000000000..19f47f3d7
--- /dev/null
+++ b/src/java/org/apache/fop/util/text/HexFieldPart.java
@@ -0,0 +1,84 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/* $Id$ */
+
+package org.apache.fop.util.text;
+
+import java.util.Map;
+
+import org.apache.fop.util.text.AdvancedMessageFormat.Part;
+import org.apache.fop.util.text.AdvancedMessageFormat.PartFactory;
+
+/**
+ * Function formatting a number or character to a hex value.
+ */
+public class HexFieldPart implements Part {
+
+    private String fieldName;
+    
+    /**
+     * Creates a new hex field part
+     * @param fieldName the field name
+     */
+    public HexFieldPart(String fieldName) {
+        this.fieldName = fieldName;
+    }
+    
+    /** {@inheritDoc} */
+    public boolean isGenerated(Map params) {
+        Object obj = params.get(fieldName);
+        return obj != null;
+    }
+
+    /** {@inheritDoc} */
+    public void write(StringBuffer sb, Map params) {
+        if (!params.containsKey(fieldName)) {
+            throw new IllegalArgumentException(
+                    "Message pattern contains unsupported field name: " + fieldName);
+        }
+        Object obj = params.get(fieldName);
+        if (obj instanceof Character) {
+            sb.append(Integer.toHexString(((Character)obj).charValue()));
+        } else if (obj instanceof Number) {
+            sb.append(Integer.toHexString(((Number)obj).intValue()));
+        } else {
+            throw new IllegalArgumentException("Incompatible value for hex field part: "
+                    + obj.getClass().getName());
+        }
+    }
+
+    /** {@inheritDoc} */
+    public String toString() {
+        return "{" + this.fieldName + ",hex}";
+    }
+    
+    /** Factory for {@link HexFieldPart}. */
+    public static class Factory implements PartFactory {
+
+        /** {@inheritDoc} */
+        public Part newPart(String fieldName, String values) {
+            return new HexFieldPart(fieldName);
+        }
+        
+        /** {@inheritDoc} */
+        public String getFormat() {
+            return "hex";
+        }
+        
+    }
+}
diff --git a/src/java/org/apache/fop/util/text/IfFieldPart.java b/src/java/org/apache/fop/util/text/IfFieldPart.java
new file mode 100644
index 000000000..31cd8f36c
--- /dev/null
+++ b/src/java/org/apache/fop/util/text/IfFieldPart.java
@@ -0,0 +1,116 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/* $Id$ */
+
+package org.apache.fop.util.text;
+
+import java.util.Map;
+
+import org.apache.fop.util.text.AdvancedMessageFormat.Part;
+import org.apache.fop.util.text.AdvancedMessageFormat.PartFactory;
+
+/**
+ * Defines an "if" field part that checks if field's value is true or false.
+ * It returns either of two possible values attached as additional part parameters. Example:
+ * <code>{field,if,Yes,No}</code>
+ */
+public class IfFieldPart implements Part {
+    
+    /** the field name for the part */
+    protected String fieldName;
+    /** the value being returned if the field is true */
+    protected String ifValue;
+    /** the value being returned if the field is false */
+    protected String elseValue;
+    
+    /**
+     * Creates a new "if" field part.
+     * @param fieldName the field name
+     * @param values the unparsed parameter values
+     */
+    public IfFieldPart(String fieldName, String values) {
+        this.fieldName = fieldName;
+        parseValues(values);
+    }
+
+    /**
+     * Parses the parameter values
+     * @param values the unparsed parameter values
+     */
+    protected void parseValues(String values) {
+        String[] parts = AdvancedMessageFormat.COMMA_SEPARATOR_REGEX.split(values, 2);
+        if (parts.length == 2) {
+            ifValue = AdvancedMessageFormat.unescapeComma(parts[0]);
+            elseValue = AdvancedMessageFormat.unescapeComma(parts[1]);
+        } else {
+            ifValue = AdvancedMessageFormat.unescapeComma(values);
+        }
+    }
+    
+    /** {@inheritDoc} */
+    public void write(StringBuffer sb, Map params) {
+        boolean isTrue = isTrue(params);
+        if (isTrue) {
+            sb.append(ifValue);
+        } else if (elseValue != null) {
+            sb.append(elseValue);
+        }
+    }
+
+    /**
+     * Indicates whether the field's value is true. If the field is not a boolen, it is true
+     * if the field is not null.
+     * @param params the message parameters
+     * @return true the field's value as boolean
+     */
+    protected boolean isTrue(Map params) {
+        Object obj = params.get(fieldName);
+        if (obj instanceof Boolean) {
+            return ((Boolean)obj).booleanValue();
+        } else {
+            return (obj != null);
+        }
+    }
+
+    /** {@inheritDoc} */
+    public boolean isGenerated(Map params) {
+        return isTrue(params) || (elseValue != null);
+    }
+    
+    /** {@inheritDoc} */
+    public String toString() {
+        return "{" + this.fieldName + ", if...}";
+    }
+    
+    /**
+     * Part factory for "if".
+     */
+    public static class Factory implements PartFactory {
+
+        /** {@inheritDoc} */
+        public Part newPart(String fieldName, String values) {
+            return new IfFieldPart(fieldName, values);
+        }
+        
+        /** {@inheritDoc} */
+        public String getFormat() {
+            return "if";
+        }
+        
+    }
+}
\ No newline at end of file
diff --git a/src/java/org/apache/fop/util/text/LocatorFormatter.java b/src/java/org/apache/fop/util/text/LocatorFormatter.java
new file mode 100644
index 000000000..d9532c66d
--- /dev/null
+++ b/src/java/org/apache/fop/util/text/LocatorFormatter.java
@@ -0,0 +1,42 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/* $Id$ */
+
+package org.apache.fop.util.text;
+
+import org.xml.sax.Locator;
+
+import org.apache.fop.util.text.AdvancedMessageFormat.ObjectFormatter;
+
+/**
+ * Object formatter for the SAX Locator object.
+ */
+public class LocatorFormatter implements ObjectFormatter {
+
+    /** {@inheritDoc} */
+    public void format(StringBuffer sb, Object obj) {
+        Locator loc = (Locator)obj;
+        sb.append(loc.getLineNumber()).append(":").append(loc.getColumnNumber());
+    }
+
+    /** {@inheritDoc} */
+    public boolean supportsObject(Object obj) {
+        return obj instanceof Locator;
+    }
+    
+}
\ No newline at end of file