modules/fxgutils/src/java/com/adobe/internal/fxg/dom/DOMParserHelper.java - flex-sdk - Git at Google

 /*
  *
  *  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.
  *
  */

 package com.adobe.internal.fxg.dom;

 import static com.adobe.fxg.FXGConstants.FXG_FILLMODE_CLIP_VALUE;
 import static com.adobe.fxg.FXGConstants.FXG_FILLMODE_REPEAT_VALUE;
 import static com.adobe.fxg.FXGConstants.FXG_FILLMODE_SCALE_VALUE;
 import static com.adobe.fxg.FXGConstants.FXG_INTERPOLATION_LINEARRGB_VALUE;
 import static com.adobe.fxg.FXGConstants.FXG_INTERPOLATION_RGB_VALUE;
 import static com.adobe.fxg.FXGConstants.FXG_MASK_ALPHA_VALUE;
 import static com.adobe.fxg.FXGConstants.FXG_MASK_CLIP_VALUE;
 import static com.adobe.fxg.FXGConstants.FXG_MASK_LUMINOSITY_VALUE;
 import static com.adobe.fxg.FXGConstants.FXG_SPREADMETHOD_PAD_VALUE;
 import static com.adobe.fxg.FXGConstants.FXG_SPREADMETHOD_REFLECT_VALUE;
 import static com.adobe.fxg.FXGConstants.FXG_SPREADMETHOD_REPEAT_VALUE;

 import java.util.regex.Matcher;
 import java.util.regex.Pattern;

 import com.adobe.fxg.FXGException;
 import com.adobe.fxg.FXGVersion;
 import com.adobe.fxg.dom.FXGNode;
 import com.adobe.fxg.util.FXGLog;
 import com.adobe.fxg.util.FXGLogger;
 import com.adobe.internal.fxg.dom.types.FillMode;
 import com.adobe.internal.fxg.dom.types.InterpolationMethod;
 import com.adobe.internal.fxg.dom.types.MaskType;
 import com.adobe.internal.fxg.dom.types.SpreadMethod;

 /**
  * Utilities to help parsing FXG.
  *
  * @since 2.0
  * @author Min Plunkett
  */
 public class DOMParserHelper
 {
     private static Pattern idPattern = Pattern.compile ("[a-zA-Z_][a-zA-Z_0-9]*");
     private static Pattern rgbPattern = Pattern.compile ("#[0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F]");

     /**
      * Convert an FXG String value to a boolean.
      *
      * @param node - the FXG node.
      * @param value - the FXG String value.
      * @param name - the FXG attribute name.
      * @return true for the String 'true' (case insensitive), otherwise false.
      * @throws FXGException if the String did not represent a boolean "true" or
      * "false" (case sensitive).
      */
     public static boolean parseBoolean(FXGNode node, String value, String name)
     {
         if (value.equals("true"))
             return true;
         else if (value.equals("false"))
             return false;
         throw new FXGException(node.getStartLine(), node.getStartColumn(), "InvalidBooleanValue", name, value);
     }

     /**
      * Convert an FXG hexadecimal color String to an int. The
      * format must be a '#' character followed by six hexadecimal characters,
      * i.e. '#RRGGBB'.
      *
      * @param node - the FXG node.
      * @param value - an FXG a hexadecimal color String.
      * @param name - the FXG attribute name.
      * @return an RGB color represented as an int.
      * @throws FXGException if the String did not represent a valid color value.
      */
     public static int parseRGB(FXGNode node, String value, String name)
     {
         Matcher m;

         m = rgbPattern.matcher(value);
         if (!m.matches ())
         {
             //Exception: Invalid identifier format: {0}
             throw new FXGException(node.getStartLine(), node.getStartColumn(), "InvalidColorValue", name, value);
         }

         value = value.substring(1);

         int a = 255;
         int r = Integer.parseInt(value.substring(0, 2), 16) & 0xFF;
         int g = Integer.parseInt(value.substring(2, 4), 16) & 0xFF;
         int b = Integer.parseInt(value.substring(4, 6), 16) & 0xFF;

         return  (a << 24) | (r << 16) | (g << 8) | b;
     }

     /**
      * Convert an FXG String value to a double.
      *
      * @param node - the FXG node.
      * @param value - the FXG String value.
      * @param name - the FXG attribute name.
      * @return the double precision floating point value represented by the
      * String.
      * @throws FXGException if the String did not represent a double.
      */
     public static double parseDouble(FXGNode node, String value, String name)
     {
         try
         {
             return Double.parseDouble(value);
         }
         catch(NumberFormatException e)
         {
             throw new FXGException(node.getStartLine(), node.getStartColumn(), "InvalidDoubleValue", name, value);
         }
     }

     /**
      * Convert an FXG String value to a double after taking care of the % sign.
      *
      * @param node - the FXG node.
      * @param value - the FXG String value.
      * @param name - the FXG attribute name.
      * @return the double precision floating point value represented by the
      * String.
      * @throws FXGException if the String did not represent a double.
      */
     public static double parsePercent(FXGNode node, String value, String name)
     {
         if (value.length() != 0 && value.charAt(value.length()-1) == '%')
         {
             String doubleValue = value.substring(0, value.length()-1);
             try
             {
                 return parseDouble(node, doubleValue, name);
             }
             catch(FXGException e)
             {
                 throw new FXGException(node.getStartLine(), node.getStartColumn(), "InvalidPercentValue", name, value);
             }
         }
         else
         {
             return parseDouble(node, value, name);
         }
     }

     /**
      * Convert an FXG String value to a double after taking care of the % sign.
      * If the value is double, it is checked against the specified range
      * (inclusive).
      *
      * @param node - the FXG node.
      * @param value - the FXG String value.
      * @param name - the FXG attribute name.
      * @param min - the smallest double value that the result must be greater
      * or equal to.
      * @param max - the largest double value that the result must be smaller
      * than or equal to.
      * @param defaultValue - the default double value; if the encountered minor
      * version is later than the supported minor version and the attribute value
      *  is out-of-range, the default value is returned.
      * @return the double precision floating point value represented by the
      * String.
      * @throws FXGException if the String did not represent a double
      * or the value isn't within the specified range (inclusive).
      */
     public static double parseNumberPercent(FXGNode node, String value, String name, double min, double max, double defaultValue)
     {
         if (value.length() != 0 && value.charAt(value.length()-1) == '%')
         {
             String doubleValue = value.substring(0, value.length()-1);
             try
             {
                 return parseDouble(node, doubleValue, name, min, max, defaultValue);
             }
             catch(FXGException e)
             {
                 throw new FXGException(node.getStartLine(), node.getStartColumn(), "InvalidPercentValue", name, value);
             }
         }
         else
         {
             return parseDouble(node, value, name, min, max, defaultValue);
         }
     }

     /**
      * Convert an FXG String value to a double after taking care of the % sign.
      * If the value is double, it is checked against the specified range
      * (inclusive). There are separate ranges for percent and number.
      *
      * @param node - the FXG node.
      * @param value - the FXG String value.
      * @param defaultValue - the default double value; if the encountered minor
      * version is later than the supported minor version and the attribute value
      * is out-of-range, the default value is returned.
      * @param name the name
      * @param minNumber the min number
      * @param maxNumber the max number
      * @param minPercent the min percent
      * @param maxPercent the max percent
      *
      * @return the double precision floating point value represented by the
      * String.
      *
      * @throws FXGException if the String did not represent a double
      * or the value isn't within the specified range (inclusive).
      */
     public static double parseNumberPercentWithSeparateRange(FXGNode node, String value, String name, double minNumber,
             double maxNumber, double minPercent, double maxPercent,
             double defaultValue)
     {
         if (value.length() != 0 && value.charAt(value.length()-1) == '%')
         {
             String doubleValue = value.substring(0, value.length()-1);
             try
             {
                 return parseDouble(node, doubleValue, name, minPercent, maxPercent, defaultValue);
             }
             catch(FXGException e)
             {
                 throw new FXGException(node.getStartLine(), node.getStartColumn(), "InvalidPercentValue", name, value);
             }
         }
         else
         {
             return parseDouble(node, value, name, minNumber, maxNumber, defaultValue);
         }
     }

     /**
      * Convert an FXG String value to a double and check that the result is
      * within the specified range (inclusive).
      *
      * @param node - the FXG node.
      * @param value - the FXG String value.
      * @param name - the FXG attribute name.
      * @param min - the smallest double value that the result must be greater
      * or equal to.
      * @param max - the largest double value that the result must be smaller
      * than or equal to.
      * @param defaultValue - the default double value; if the encountered minor
      * version is later than the supported minor version and the attribute value
      *  is out-of-range, the default value is returned.
      * @return the double precision floating point value represented by the
      * String.
      * @throws FXGException if the String did not represent a double or the
      * result did not lie within the specified
      * range.
      */
     public static double parseDouble(FXGNode node, String value, String name, double min, double max, double defaultValue)
     {
         try
         {
             double d = Double.parseDouble(value);
             if (d >= min && d <= max)
             {
                 return d;
             }
         }
         catch(NumberFormatException e)
         {
             throw new FXGException(node.getStartLine(), node.getStartColumn(), "InvalidDoubleValue", name, value);
         }

         if (((AbstractFXGNode)node).isVersionGreaterThanCompiler())
         {
             // Warning: Minor version of this FXG file is greater than minor
             // version supported by this compiler. Use default value if an
             // attribute value is out of range.
             FXGLog.getLogger().log(FXGLogger.WARN, "DefaultAttributeValue", null, ((AbstractFXGNode)node).getDocumentName(), node.getStartLine(), node.getStartColumn(), defaultValue, name);
             return defaultValue;
         }
         else
         {
             // Exception:Numeric value {0} must be greater than or equal to {1}
             // and less than or equal to {2}.
             throw new FXGException(node.getStartLine(), node.getStartColumn(), "OutOfRangeValue", name, value, min, max);
         }
     }

     /**
      * Convert an FXG String value to a float.
      *
      * @param node - the FXG node.
      * @param value - the FXG String value.
      * @return the floating point value represented by the String.
      * @throws FXGException if the String did not represent a double.
      */
     public static float parseFloat(FXGNode node, String value)
     {
         try
         {
             return Float.parseFloat(value);
         }
         catch(NumberFormatException e)
         {
             throw new FXGException(node.getStartLine(), node.getStartColumn(), "InvalidFloatValue", value);
         }
     }

     /**
      * Convert an FXG String value to an int and check that the result is
      * within the specified range (inclusive).
      *
      * @param node - the FXG node.
      * @param value - the FXG String value.
      * @param name - the FXG attribute name.
      * @param min - the smallest int value that the result must be greater
      * or equal to.
      * @param max - the largest int value that the result must be smaller
      * than or equal to.
      * @param defaultValue - the default int value; if the encountered minor
      * version is later than the supported minor version and the attribute value
      *  is out-of-range, the default value is returned.
      * @return the integer value represented by the String.
      * @throws FXGException if the String did not represent an integer or the
      * result did not lie within the specified range.
      */
     public static int parseInt(FXGNode node, String value, String name, int min, int max, int defaultValue)
     {
         int i = parseInt(node, value, name);
         if (i >= min && i <= max)
         {
             return i;
         }

         if (((AbstractFXGNode)node).isVersionGreaterThanCompiler())
         {
             // Warning: Minor version of this FXG file is greater than minor
             // version supported by this compiler. Use default value if an
             // attribute value is out of range.
             FXGLog.getLogger().log(FXGLogger.WARN, "DefaultAttributeValue", null, ((AbstractFXGNode)node).getDocumentName(), node.getStartLine(), node.getStartColumn(), defaultValue, name);
             return defaultValue;
         }
         else
         {
             // Exception:Numeric value {0} must be greater than or equal to {1}
             // and less than or equal to {2}.
             throw new FXGException(node.getStartLine(), node.getStartColumn(), "OutOfRangeValue", value, min, max);
         }
     }

     /**
      * Convert an FXG String value to a integer.
      *
      * @param node - the FXG node.
      * @param value - the FXG String value.
      * @param name - the FXG attribute name.
      * @return the integer value represented by the String.
      * @throws FXGException if the String did not represent a integer.
      */
     public static int parseInt(FXGNode node, String value, String name)
     {
         try
         {
             return Integer.parseInt(value);
         }
         catch(NumberFormatException e)
         {
             throw new FXGException(node.getStartLine(), node.getStartColumn(), "InvalidIntegerValue", name, value);
         }
     }

     /**
      * Convert an FXG String value to an InterpolationMethod enumeration.
      *
      * @param node - the FXG node.
      * @param value - the FXG String value
      * @param name - the FXG attribute name.
      * @param defaultValue - the FXG InterpolationMethod default value
      * @return the matching InterpolationMethod; if the encountered minor
      * version is later than the supported minor version and the attribute value
      *  is out-of-range, the default value is returned.
      * @throws FXGException if the String did not match a known
      * InterpolationMethod.
      */
     public static InterpolationMethod parseInterpolationMethod(FXGNode node, String value, String name, InterpolationMethod defaultValue)
     {
         if (FXG_INTERPOLATION_RGB_VALUE.equals(value))
         {
             return InterpolationMethod.RGB;
         }
         else if (FXG_INTERPOLATION_LINEARRGB_VALUE.equals(value))
         {
             return InterpolationMethod.LINEAR_RGB;
         }
         else
         {
             if (((AbstractFXGNode)node).isVersionGreaterThanCompiler())
             {
                 // Warning: Minor version of this FXG file is greater than minor
                 // version supported by this compiler. Use default value if an
                 // attribute value is out of range.
                 FXGLog.getLogger().log(FXGLogger.WARN, "DefaultAttributeValue", null, ((AbstractFXGNode)node).getDocumentName(), node.getStartLine(), node.getStartColumn(), defaultValue, name);
                 return defaultValue;
             }
             else
             {
                 // Exception:Unknown interpolation method {0}.
                 throw new FXGException(node.getStartLine(), node.getStartColumn(), "UnknownInterpolationMethod", value);
             }
         }
     }

     /**
      * Convert an FXG String value to a MaskType enumeration.
      *
      * @param node - the FXG node.
      * @param value - the FXG String value
      * @param name - the FXG attribute name.
      * @param defaultValue - the FXG MaskType default value; if the encountered
      * minor version is later than the supported minor version and the attribute
      *  value is out-of-range, the default value is returned.
      * @return the matching MaskType
      * @throws FXGException if the String did not match a known
      * MaskType.
      */
     public static MaskType parseMaskType(FXGNode node, String value, String name, MaskType defaultValue)
     {
         if (FXG_MASK_CLIP_VALUE.equals(value))
         {
             return MaskType.CLIP;
         }
         else if (FXG_MASK_ALPHA_VALUE.equals(value))
         {
             return MaskType.ALPHA;
         }
         else if (((AbstractFXGNode)node).getFileVersion().equalTo(FXGVersion.v1_0))
         {
             // FXG 1.0 does not support any more maskTypes
             // Exception:Unknown maskType {0}.
             throw new FXGException(node.getStartLine(), node.getStartColumn(), "UnknownMaskType", value);
         }
         else if (FXG_MASK_LUMINOSITY_VALUE.equals(value))
         {
             return MaskType.LUMINOSITY;
         }
         else
         {
             if (((AbstractFXGNode)node).isVersionGreaterThanCompiler())
             {
                 // Warning: Minor version of this FXG file is greater than minor
                 // version supported by this compiler. Use default value if an
                 // attribute value is out of range.
                 FXGLog.getLogger().log(FXGLogger.WARN, "DefaultAttributeValue", null, ((AbstractFXGNode)node).getDocumentName(), node.getStartLine(), node.getStartColumn(), defaultValue, name);
                 return defaultValue;
             }
             else
             {
                 // Exception:Unknown maskType {0}.
                 throw new FXGException(node.getStartLine(), node.getStartColumn(), "UnknownMaskType", value);
             }
         }
     }

     /**
      * Convert an FXG String value to a fillMode enumeration.
      *
      * @param node - the FXG node.
      * @param value - the FXG String value.
      * @param name - the FXG attribute name.
      * @param defaultValue the default value
      *
      * @return the matching fillMode value.
      *
      * @throws FXGException if the String did not match a known
      * fillMode value.
      */
     public static FillMode parseFillMode(FXGNode node, String value, String name, FillMode defaultValue)
     {
         if (FXG_FILLMODE_CLIP_VALUE.equals(value))
         {
             return FillMode.CLIP;
         }
         else if (FXG_FILLMODE_REPEAT_VALUE.equals(value))
         {
             return FillMode.REPEAT;
         }
         else if (FXG_FILLMODE_SCALE_VALUE.equals(value))
         {
             return FillMode.SCALE;
         }
         else
         {
             if (((AbstractFXGNode)node).isVersionGreaterThanCompiler())
             {
                 // Warning: Minor version of this FXG file is greater than minor
                 // version supported by this compiler. Use default value if an
                 // attribute value is out of range.
                 FXGLog.getLogger().log(FXGLogger.WARN, "DefaultAttributeValue", null, ((AbstractFXGNode)node).getDocumentName(), node.getStartLine(), node.getStartColumn(), defaultValue, name);
                 return defaultValue;
             }
             else
             {
                 // Exception:Unknown fill mode: {0}.
                 throw new FXGException(node.getStartLine(), node.getStartColumn(), "UnknownFillMode", value);
             }
         }

     }

     /**
      * Convert an FXG String value to a SpreadMethod enumeration.
      *
      * @param node - the FXG node.
      * @param value - the FXG String value
      * @param name - the FXG attribute name
      * @param defaultValue - the FXG SpreadMethod default value
      * @return the matching SpreadMethod; if the encountered minor version is
      * later than the supported minor version and the attribute value is
      * out-of-range, the default value is returned.
      * @throws FXGException if the String did not match a known
      * SpreadMethod.
      */
     public static SpreadMethod parseSpreadMethod(FXGNode node, String value, String name, SpreadMethod defaultValue)
     {
         if (FXG_SPREADMETHOD_PAD_VALUE.equals(value))
         {
             return SpreadMethod.PAD;
         }
         else if (FXG_SPREADMETHOD_REFLECT_VALUE.equals(value))
         {
             return SpreadMethod.REFLECT;
         }
         else if (FXG_SPREADMETHOD_REPEAT_VALUE.equals(value))
         {
             return SpreadMethod.REPEAT;
         }
         else
         {
             if (((AbstractFXGNode)node).isVersionGreaterThanCompiler())
             {
                 // Warning: Minor version of this FXG file is greater than minor
                 // version supported by this compiler. Use default value if an
                 // attribute value is out of range.
                 FXGLog.getLogger().log(FXGLogger.WARN, "DefaultAttributeValue", null, ((AbstractFXGNode)node).getDocumentName(), node.getStartLine(), node.getStartColumn(), defaultValue, name);
                 return defaultValue;
             }
             else
             {
                 // Exception:Unknown spreadMethod {0}.
                 throw new FXGException(node.getStartLine(), node.getStartColumn(), "UnknownSpreadMethod", value);
             }
         }
     }

     /**
      * Convert an FXG String value to a Identifier matching pattern
      * [a-zA-Z_][a-zA-Z_0-9]*.
      *
      * @param node - the FXG node
      * @param value - the FXG String value
      * @param name - the FXG attribute name
      * @param defaultValue the default value
      *
      * @return the string
      *
      * @throws FXGException if the String did not match the pattern.
      */
     public static String parseIdentifier(FXGNode node, String value, String name, String defaultValue)
     {
         Matcher m;

         m = idPattern.matcher(value);
         if (m.matches ())
         {
             return value;
         }
         else
         {
             if (((AbstractFXGNode)node).isVersionGreaterThanCompiler())
             {
                 // Warning: Minor version of this FXG file is greater than minor
                 // version supported by this compiler. Use default value if an
                 // attribute value is out of range.
                 FXGLog.getLogger().log(FXGLogger.WARN, "DefaultAttributeValue", null, ((AbstractFXGNode)node).getDocumentName(), node.getStartLine(), node.getStartColumn(), defaultValue, name);
                 return defaultValue;
             }
             else
             {
                 //Exception: Invalid identifier format: {0}
                 throw new FXGException(node.getStartLine(), node.getStartColumn(), "InvalidIdentifierFormat", value);
             }
         }
     }
 }
	/*
	*
	* 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.
	*
	*/

	package com.adobe.internal.fxg.dom;

	import static com.adobe.fxg.FXGConstants.FXG_FILLMODE_CLIP_VALUE;
	import static com.adobe.fxg.FXGConstants.FXG_FILLMODE_REPEAT_VALUE;
	import static com.adobe.fxg.FXGConstants.FXG_FILLMODE_SCALE_VALUE;
	import static com.adobe.fxg.FXGConstants.FXG_INTERPOLATION_LINEARRGB_VALUE;
	import static com.adobe.fxg.FXGConstants.FXG_INTERPOLATION_RGB_VALUE;
	import static com.adobe.fxg.FXGConstants.FXG_MASK_ALPHA_VALUE;
	import static com.adobe.fxg.FXGConstants.FXG_MASK_CLIP_VALUE;
	import static com.adobe.fxg.FXGConstants.FXG_MASK_LUMINOSITY_VALUE;
	import static com.adobe.fxg.FXGConstants.FXG_SPREADMETHOD_PAD_VALUE;
	import static com.adobe.fxg.FXGConstants.FXG_SPREADMETHOD_REFLECT_VALUE;
	import static com.adobe.fxg.FXGConstants.FXG_SPREADMETHOD_REPEAT_VALUE;

	import java.util.regex.Matcher;
	import java.util.regex.Pattern;

	import com.adobe.fxg.FXGException;
	import com.adobe.fxg.FXGVersion;
	import com.adobe.fxg.dom.FXGNode;
	import com.adobe.fxg.util.FXGLog;
	import com.adobe.fxg.util.FXGLogger;
	import com.adobe.internal.fxg.dom.types.FillMode;
	import com.adobe.internal.fxg.dom.types.InterpolationMethod;
	import com.adobe.internal.fxg.dom.types.MaskType;
	import com.adobe.internal.fxg.dom.types.SpreadMethod;

	/**
	* Utilities to help parsing FXG.
	*
	* @since 2.0
	* @author Min Plunkett
	*/
	public class DOMParserHelper
	{
	private static Pattern idPattern = Pattern.compile ("[a-zA-Z_][a-zA-Z_0-9]*");
	private static Pattern rgbPattern = Pattern.compile ("#[0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F]");

	/**
	* Convert an FXG String value to a boolean.
	*
	* @param node - the FXG node.
	* @param value - the FXG String value.
	* @param name - the FXG attribute name.
	* @return true for the String 'true' (case insensitive), otherwise false.
	* @throws FXGException if the String did not represent a boolean "true" or
	* "false" (case sensitive).
	*/
	public static boolean parseBoolean(FXGNode node, String value, String name)
	{
	if (value.equals("true"))
	return true;
	else if (value.equals("false"))
	return false;
	throw new FXGException(node.getStartLine(), node.getStartColumn(), "InvalidBooleanValue", name, value);
	}

	/**
	* Convert an FXG hexadecimal color String to an int. The
	* format must be a '#' character followed by six hexadecimal characters,
	* i.e. '#RRGGBB'.
	*
	* @param node - the FXG node.
	* @param value - an FXG a hexadecimal color String.
	* @param name - the FXG attribute name.
	* @return an RGB color represented as an int.
	* @throws FXGException if the String did not represent a valid color value.
	*/
	public static int parseRGB(FXGNode node, String value, String name)
	{
	Matcher m;

	m = rgbPattern.matcher(value);
	if (!m.matches ())
	{
	//Exception: Invalid identifier format: {0}
	throw new FXGException(node.getStartLine(), node.getStartColumn(), "InvalidColorValue", name, value);
	}

	value = value.substring(1);

	int a = 255;
	int r = Integer.parseInt(value.substring(0, 2), 16) & 0xFF;
	int g = Integer.parseInt(value.substring(2, 4), 16) & 0xFF;
	int b = Integer.parseInt(value.substring(4, 6), 16) & 0xFF;

	return (a << 24) \| (r << 16) \| (g << 8) \| b;
	}

	/**
	* Convert an FXG String value to a double.
	*
	* @param node - the FXG node.
	* @param value - the FXG String value.
	* @param name - the FXG attribute name.
	* @return the double precision floating point value represented by the
	* String.
	* @throws FXGException if the String did not represent a double.
	*/
	public static double parseDouble(FXGNode node, String value, String name)
	{
	try
	{
	return Double.parseDouble(value);
	}
	catch(NumberFormatException e)
	{
	throw new FXGException(node.getStartLine(), node.getStartColumn(), "InvalidDoubleValue", name, value);
	}
	}

	/**
	* Convert an FXG String value to a double after taking care of the % sign.
	*
	* @param node - the FXG node.
	* @param value - the FXG String value.
	* @param name - the FXG attribute name.
	* @return the double precision floating point value represented by the
	* String.
	* @throws FXGException if the String did not represent a double.
	*/
	public static double parsePercent(FXGNode node, String value, String name)
	{
	if (value.length() != 0 && value.charAt(value.length()-1) == '%')
	{
	String doubleValue = value.substring(0, value.length()-1);
	try
	{
	return parseDouble(node, doubleValue, name);
	}
	catch(FXGException e)
	{
	throw new FXGException(node.getStartLine(), node.getStartColumn(), "InvalidPercentValue", name, value);
	}
	}
	else
	{
	return parseDouble(node, value, name);
	}
	}

	/**
	* Convert an FXG String value to a double after taking care of the % sign.
	* If the value is double, it is checked against the specified range
	* (inclusive).
	*
	* @param node - the FXG node.
	* @param value - the FXG String value.
	* @param name - the FXG attribute name.
	* @param min - the smallest double value that the result must be greater
	* or equal to.
	* @param max - the largest double value that the result must be smaller
	* than or equal to.
	* @param defaultValue - the default double value; if the encountered minor
	* version is later than the supported minor version and the attribute value
	* is out-of-range, the default value is returned.
	* @return the double precision floating point value represented by the
	* String.
	* @throws FXGException if the String did not represent a double
	* or the value isn't within the specified range (inclusive).
	*/
	public static double parseNumberPercent(FXGNode node, String value, String name, double min, double max, double defaultValue)
	{
	if (value.length() != 0 && value.charAt(value.length()-1) == '%')
	{
	String doubleValue = value.substring(0, value.length()-1);
	try
	{
	return parseDouble(node, doubleValue, name, min, max, defaultValue);
	}
	catch(FXGException e)
	{
	throw new FXGException(node.getStartLine(), node.getStartColumn(), "InvalidPercentValue", name, value);
	}
	}
	else
	{
	return parseDouble(node, value, name, min, max, defaultValue);
	}
	}

	/**
	* Convert an FXG String value to a double after taking care of the % sign.
	* If the value is double, it is checked against the specified range
	* (inclusive). There are separate ranges for percent and number.
	*
	* @param node - the FXG node.
	* @param value - the FXG String value.
	* @param defaultValue - the default double value; if the encountered minor
	* version is later than the supported minor version and the attribute value
	* is out-of-range, the default value is returned.
	* @param name the name
	* @param minNumber the min number
	* @param maxNumber the max number
	* @param minPercent the min percent
	* @param maxPercent the max percent
	*
	* @return the double precision floating point value represented by the
	* String.
	*
	* @throws FXGException if the String did not represent a double
	* or the value isn't within the specified range (inclusive).
	*/
	public static double parseNumberPercentWithSeparateRange(FXGNode node, String value, String name, double minNumber,
	double maxNumber, double minPercent, double maxPercent,
	double defaultValue)
	{
	if (value.length() != 0 && value.charAt(value.length()-1) == '%')
	{
	String doubleValue = value.substring(0, value.length()-1);
	try
	{
	return parseDouble(node, doubleValue, name, minPercent, maxPercent, defaultValue);
	}
	catch(FXGException e)
	{
	throw new FXGException(node.getStartLine(), node.getStartColumn(), "InvalidPercentValue", name, value);
	}
	}
	else
	{
	return parseDouble(node, value, name, minNumber, maxNumber, defaultValue);
	}
	}

	/**
	* Convert an FXG String value to a double and check that the result is
	* within the specified range (inclusive).
	*
	* @param node - the FXG node.
	* @param value - the FXG String value.
	* @param name - the FXG attribute name.
	* @param min - the smallest double value that the result must be greater
	* or equal to.
	* @param max - the largest double value that the result must be smaller
	* than or equal to.
	* @param defaultValue - the default double value; if the encountered minor
	* version is later than the supported minor version and the attribute value
	* is out-of-range, the default value is returned.
	* @return the double precision floating point value represented by the
	* String.
	* @throws FXGException if the String did not represent a double or the
	* result did not lie within the specified
	* range.
	*/
	public static double parseDouble(FXGNode node, String value, String name, double min, double max, double defaultValue)
	{
	try
	{
	double d = Double.parseDouble(value);
	if (d >= min && d <= max)
	{
	return d;
	}
	}
	catch(NumberFormatException e)
	{
	throw new FXGException(node.getStartLine(), node.getStartColumn(), "InvalidDoubleValue", name, value);
	}

	if (((AbstractFXGNode)node).isVersionGreaterThanCompiler())
	{
	// Warning: Minor version of this FXG file is greater than minor
	// version supported by this compiler. Use default value if an
	// attribute value is out of range.
	FXGLog.getLogger().log(FXGLogger.WARN, "DefaultAttributeValue", null, ((AbstractFXGNode)node).getDocumentName(), node.getStartLine(), node.getStartColumn(), defaultValue, name);
	return defaultValue;
	}
	else
	{
	// Exception:Numeric value {0} must be greater than or equal to {1}
	// and less than or equal to {2}.
	throw new FXGException(node.getStartLine(), node.getStartColumn(), "OutOfRangeValue", name, value, min, max);
	}
	}

	/**
	* Convert an FXG String value to a float.
	*
	* @param node - the FXG node.
	* @param value - the FXG String value.
	* @return the floating point value represented by the String.
	* @throws FXGException if the String did not represent a double.
	*/
	public static float parseFloat(FXGNode node, String value)
	{
	try
	{
	return Float.parseFloat(value);
	}
	catch(NumberFormatException e)
	{
	throw new FXGException(node.getStartLine(), node.getStartColumn(), "InvalidFloatValue", value);
	}
	}

	/**
	* Convert an FXG String value to an int and check that the result is
	* within the specified range (inclusive).
	*
	* @param node - the FXG node.
	* @param value - the FXG String value.
	* @param name - the FXG attribute name.
	* @param min - the smallest int value that the result must be greater
	* or equal to.
	* @param max - the largest int value that the result must be smaller
	* than or equal to.
	* @param defaultValue - the default int value; if the encountered minor
	* version is later than the supported minor version and the attribute value
	* is out-of-range, the default value is returned.
	* @return the integer value represented by the String.
	* @throws FXGException if the String did not represent an integer or the
	* result did not lie within the specified range.
	*/
	public static int parseInt(FXGNode node, String value, String name, int min, int max, int defaultValue)
	{
	int i = parseInt(node, value, name);
	if (i >= min && i <= max)
	{
	return i;
	}

	if (((AbstractFXGNode)node).isVersionGreaterThanCompiler())
	{
	// Warning: Minor version of this FXG file is greater than minor
	// version supported by this compiler. Use default value if an
	// attribute value is out of range.
	FXGLog.getLogger().log(FXGLogger.WARN, "DefaultAttributeValue", null, ((AbstractFXGNode)node).getDocumentName(), node.getStartLine(), node.getStartColumn(), defaultValue, name);
	return defaultValue;
	}
	else
	{
	// Exception:Numeric value {0} must be greater than or equal to {1}
	// and less than or equal to {2}.
	throw new FXGException(node.getStartLine(), node.getStartColumn(), "OutOfRangeValue", value, min, max);
	}
	}

	/**
	* Convert an FXG String value to a integer.
	*
	* @param node - the FXG node.
	* @param value - the FXG String value.
	* @param name - the FXG attribute name.
	* @return the integer value represented by the String.
	* @throws FXGException if the String did not represent a integer.
	*/
	public static int parseInt(FXGNode node, String value, String name)
	{
	try
	{
	return Integer.parseInt(value);
	}
	catch(NumberFormatException e)
	{
	throw new FXGException(node.getStartLine(), node.getStartColumn(), "InvalidIntegerValue", name, value);
	}
	}

	/**
	* Convert an FXG String value to an InterpolationMethod enumeration.
	*
	* @param node - the FXG node.
	* @param value - the FXG String value
	* @param name - the FXG attribute name.
	* @param defaultValue - the FXG InterpolationMethod default value
	* @return the matching InterpolationMethod; if the encountered minor
	* version is later than the supported minor version and the attribute value
	* is out-of-range, the default value is returned.
	* @throws FXGException if the String did not match a known
	* InterpolationMethod.
	*/
	public static InterpolationMethod parseInterpolationMethod(FXGNode node, String value, String name, InterpolationMethod defaultValue)
	{
	if (FXG_INTERPOLATION_RGB_VALUE.equals(value))
	{
	return InterpolationMethod.RGB;
	}
	else if (FXG_INTERPOLATION_LINEARRGB_VALUE.equals(value))
	{
	return InterpolationMethod.LINEAR_RGB;
	}
	else
	{
	if (((AbstractFXGNode)node).isVersionGreaterThanCompiler())
	{
	// Warning: Minor version of this FXG file is greater than minor
	// version supported by this compiler. Use default value if an
	// attribute value is out of range.
	FXGLog.getLogger().log(FXGLogger.WARN, "DefaultAttributeValue", null, ((AbstractFXGNode)node).getDocumentName(), node.getStartLine(), node.getStartColumn(), defaultValue, name);
	return defaultValue;
	}
	else
	{
	// Exception:Unknown interpolation method {0}.
	throw new FXGException(node.getStartLine(), node.getStartColumn(), "UnknownInterpolationMethod", value);
	}
	}
	}

	/**
	* Convert an FXG String value to a MaskType enumeration.
	*
	* @param node - the FXG node.
	* @param value - the FXG String value
	* @param name - the FXG attribute name.
	* @param defaultValue - the FXG MaskType default value; if the encountered
	* minor version is later than the supported minor version and the attribute
	* value is out-of-range, the default value is returned.
	* @return the matching MaskType
	* @throws FXGException if the String did not match a known
	* MaskType.
	*/
	public static MaskType parseMaskType(FXGNode node, String value, String name, MaskType defaultValue)
	{
	if (FXG_MASK_CLIP_VALUE.equals(value))
	{
	return MaskType.CLIP;
	}
	else if (FXG_MASK_ALPHA_VALUE.equals(value))
	{
	return MaskType.ALPHA;
	}
	else if (((AbstractFXGNode)node).getFileVersion().equalTo(FXGVersion.v1_0))
	{
	// FXG 1.0 does not support any more maskTypes
	// Exception:Unknown maskType {0}.
	throw new FXGException(node.getStartLine(), node.getStartColumn(), "UnknownMaskType", value);
	}
	else if (FXG_MASK_LUMINOSITY_VALUE.equals(value))
	{
	return MaskType.LUMINOSITY;
	}
	else
	{
	if (((AbstractFXGNode)node).isVersionGreaterThanCompiler())
	{
	// Warning: Minor version of this FXG file is greater than minor
	// version supported by this compiler. Use default value if an
	// attribute value is out of range.
	FXGLog.getLogger().log(FXGLogger.WARN, "DefaultAttributeValue", null, ((AbstractFXGNode)node).getDocumentName(), node.getStartLine(), node.getStartColumn(), defaultValue, name);
	return defaultValue;
	}
	else
	{
	// Exception:Unknown maskType {0}.
	throw new FXGException(node.getStartLine(), node.getStartColumn(), "UnknownMaskType", value);
	}
	}
	}

	/**
	* Convert an FXG String value to a fillMode enumeration.
	*
	* @param node - the FXG node.
	* @param value - the FXG String value.
	* @param name - the FXG attribute name.
	* @param defaultValue the default value
	*
	* @return the matching fillMode value.
	*
	* @throws FXGException if the String did not match a known
	* fillMode value.
	*/
	public static FillMode parseFillMode(FXGNode node, String value, String name, FillMode defaultValue)
	{
	if (FXG_FILLMODE_CLIP_VALUE.equals(value))
	{
	return FillMode.CLIP;
	}
	else if (FXG_FILLMODE_REPEAT_VALUE.equals(value))
	{
	return FillMode.REPEAT;
	}
	else if (FXG_FILLMODE_SCALE_VALUE.equals(value))
	{
	return FillMode.SCALE;
	}
	else
	{
	if (((AbstractFXGNode)node).isVersionGreaterThanCompiler())
	{
	// Warning: Minor version of this FXG file is greater than minor
	// version supported by this compiler. Use default value if an
	// attribute value is out of range.
	FXGLog.getLogger().log(FXGLogger.WARN, "DefaultAttributeValue", null, ((AbstractFXGNode)node).getDocumentName(), node.getStartLine(), node.getStartColumn(), defaultValue, name);
	return defaultValue;
	}
	else
	{
	// Exception:Unknown fill mode: {0}.
	throw new FXGException(node.getStartLine(), node.getStartColumn(), "UnknownFillMode", value);
	}
	}

	}

	/**
	* Convert an FXG String value to a SpreadMethod enumeration.
	*
	* @param node - the FXG node.
	* @param value - the FXG String value
	* @param name - the FXG attribute name
	* @param defaultValue - the FXG SpreadMethod default value
	* @return the matching SpreadMethod; if the encountered minor version is
	* later than the supported minor version and the attribute value is
	* out-of-range, the default value is returned.
	* @throws FXGException if the String did not match a known
	* SpreadMethod.
	*/
	public static SpreadMethod parseSpreadMethod(FXGNode node, String value, String name, SpreadMethod defaultValue)
	{
	if (FXG_SPREADMETHOD_PAD_VALUE.equals(value))
	{
	return SpreadMethod.PAD;
	}
	else if (FXG_SPREADMETHOD_REFLECT_VALUE.equals(value))
	{
	return SpreadMethod.REFLECT;
	}
	else if (FXG_SPREADMETHOD_REPEAT_VALUE.equals(value))
	{
	return SpreadMethod.REPEAT;
	}
	else
	{
	if (((AbstractFXGNode)node).isVersionGreaterThanCompiler())
	{
	// Warning: Minor version of this FXG file is greater than minor
	// version supported by this compiler. Use default value if an
	// attribute value is out of range.
	FXGLog.getLogger().log(FXGLogger.WARN, "DefaultAttributeValue", null, ((AbstractFXGNode)node).getDocumentName(), node.getStartLine(), node.getStartColumn(), defaultValue, name);
	return defaultValue;
	}
	else
	{
	// Exception:Unknown spreadMethod {0}.
	throw new FXGException(node.getStartLine(), node.getStartColumn(), "UnknownSpreadMethod", value);
	}
	}
	}

	/**
	* Convert an FXG String value to a Identifier matching pattern
	* [a-zA-Z_][a-zA-Z_0-9]*.
	*
	* @param node - the FXG node
	* @param value - the FXG String value
	* @param name - the FXG attribute name
	* @param defaultValue the default value
	*
	* @return the string
	*
	* @throws FXGException if the String did not match the pattern.
	*/
	public static String parseIdentifier(FXGNode node, String value, String name, String defaultValue)
	{
	Matcher m;

	m = idPattern.matcher(value);
	if (m.matches ())
	{
	return value;
	}
	else
	{
	if (((AbstractFXGNode)node).isVersionGreaterThanCompiler())
	{
	// Warning: Minor version of this FXG file is greater than minor
	// version supported by this compiler. Use default value if an
	// attribute value is out of range.
	FXGLog.getLogger().log(FXGLogger.WARN, "DefaultAttributeValue", null, ((AbstractFXGNode)node).getDocumentName(), node.getStartLine(), node.getStartColumn(), defaultValue, name);
	return defaultValue;
	}
	else
	{
	//Exception: Invalid identifier format: {0}
	throw new FXGException(node.getStartLine(), node.getStartColumn(), "InvalidIdentifierFormat", value);
	}
	}
	}
	}