bundles/org.eclipse.rap.themeeditor/src/org/eclipse/rwt/internal/theme/css/PropertyResolver.java - rap/incubator/org.eclipse.rap.incubator.themeeditor - Git at Google

 /*******************************************************************************
  * Copyright (c) 2008 Innoopract Informationssysteme GmbH.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * Contributors:
  *     Innoopract Informationssysteme GmbH - initial API and implementation
  ******************************************************************************/

 package org.eclipse.rwt.internal.theme.css;

 import java.util.*;

 import org.eclipse.rwt.internal.theme.*;

 import org.w3c.css.sac.LexicalUnit;


 public class PropertyResolver {

   private static final String BOLD = "bold";

   private static final String ITALIC = "italic";

   private static final String NORMAL = "normal";

   private static final String NONE = "none";

   private static final String HIDDEN = "hidden";

   private static final String DOTTED = "dotted";

   private static final String DASHED = "dashed";

   private static final String SOLID = "solid";

   private static final String DOUBLE = "double";

   private static final String GROOVE = "groove";

   private static final String RIDGE = "ridge";

   private static final String INSET = "inset";

   private static final String OUTSET = "outset";

   /** A thin border. */
   private static final String THIN = "thin";

   /** A medium border. */
   private static final String MEDIUM = "medium";

   /** A thick border. */
   private static final String THICK = "thick";

   private static final String TRANSPARENT = "transparent";

   private static final Map NAMED_COLORS = new HashMap();

   private static final List BORDER_STYLES = new ArrayList();

   /** Width value for "thin" identifier. */
   public static final int THIN_VALUE = 1;

   /** Width value for "medium" identifier. */
   public static final int MEDIUM_VALUE = 3;

   /** Width value for "thick" identifier. */
   public static final int THICK_VALUE = 5;

   static {
     // register 16 standard HTML colors
     NAMED_COLORS.put( "black", new int[] { 0, 0, 0 } );
     NAMED_COLORS.put( "gray", new int[] { 128, 128, 128 } );
     NAMED_COLORS.put( "silver", new int[] { 192, 192, 192 } );
     NAMED_COLORS.put( "white", new int[] { 255, 255, 255 } );
     NAMED_COLORS.put( "maroon", new int[] { 128, 0, 0 } );
     NAMED_COLORS.put( "red", new int[] { 255, 0, 0 } );
     NAMED_COLORS.put( "purple", new int[] { 128, 0, 128 } );
     NAMED_COLORS.put( "fuchsia", new int[] { 255, 0, 255 } );
     NAMED_COLORS.put( "green", new int[] { 0, 128, 0 } );
     NAMED_COLORS.put( "lime", new int[] { 0, 255, 0 } );
     NAMED_COLORS.put( "navy", new int[] { 0, 0, 128 } );
     NAMED_COLORS.put( "blue", new int[] { 0, 0, 255 } );
     NAMED_COLORS.put( "olive", new int[] { 128, 128, 0 } );
     NAMED_COLORS.put( "yellow", new int[] { 255, 255, 0 } );
     NAMED_COLORS.put( "teal", new int[] { 0, 128, 128 } );
     NAMED_COLORS.put( "aqua", new int[] { 0, 255, 255 } );
     // register border styles
     BORDER_STYLES.add( NONE ); // No border; the computed border width is zero.
     BORDER_STYLES.add( HIDDEN ); // Same as 'none', except in terms of border conflict resolution for table elements.
     BORDER_STYLES.add( DOTTED ); // The border is a series of dots.
     BORDER_STYLES.add( DASHED ); // The border is a series of short line segments.
     BORDER_STYLES.add( SOLID ); // The border is a single line segment.
     BORDER_STYLES.add( DOUBLE ); // The border is two solid lines. The sum of the two lines and the space between them equals the value of 'border-width'.
     BORDER_STYLES.add( GROOVE ); // The border looks as though it were carved into the canvas.
     BORDER_STYLES.add( RIDGE ); // The opposite of 'groove': the border looks as though it were coming out of the canvas.
     BORDER_STYLES.add( INSET ); // The border makes the box look as though it were embedded in the canvas.
     BORDER_STYLES.add( OUTSET ); // The opposite of 'inset': the border makes the box look as though it were coming out of the canvas.
   }

   public static QxColor readColor( final LexicalUnit input ) {
     QxColor result = null;
     short type = input.getLexicalUnitType();
     if( type == LexicalUnit.SAC_RGBCOLOR ) {
       LexicalUnit redParam = input.getParameters();
       LexicalUnit greenParam = redParam.getNextLexicalUnit().getNextLexicalUnit();
       LexicalUnit blueParam = greenParam.getNextLexicalUnit().getNextLexicalUnit();
       short valueType = redParam.getLexicalUnitType();
       if( greenParam.getLexicalUnitType() == valueType
           || blueParam.getLexicalUnitType() == valueType )
       {
         if( valueType == LexicalUnit.SAC_INTEGER ) {
           int red = normalizeRGBValue( redParam.getIntegerValue() );
           int green = normalizeRGBValue( greenParam.getIntegerValue() );
           int blue = normalizeRGBValue( blueParam.getIntegerValue() );
           result = QxColor.create( red, green, blue );
         } else if( valueType == LexicalUnit.SAC_PERCENTAGE ) {
           float redPercent = normalizePercentValue( redParam.getFloatValue() );
           float greenPercent = normalizePercentValue( greenParam.getFloatValue() );
           float bluePercent = normalizePercentValue( blueParam.getFloatValue() );
           int red = ( int )( 255 * redPercent / 100 );
           int green = ( int )( 255 * greenPercent / 100 );
           int blue = ( int )( 255 * bluePercent / 100 );
           result = QxColor.create( red, green, blue );
         }
       }
     } else if( type == LexicalUnit.SAC_IDENT ) {
       String string = input.getStringValue();
       if( TRANSPARENT.equals( string ) ) {
         result = QxColor.TRANSPARENT;
       } else if( NAMED_COLORS.containsKey( string.toLowerCase() ) ) {
         int[] values = ( int[] )NAMED_COLORS.get( string.toLowerCase() );
         result = QxColor.create( values[ 0 ], values[ 1 ], values[ 2 ] );
       }
     }
     return result;
   }

   public static QxDimension readDimension( final LexicalUnit unit ) {
     QxDimension result = null;
     Integer length = readSingleLengthUnit( unit );
     if( length != null ) {
       result = QxDimension.create( length.intValue() );
     }
     return result;
   }

   public static QxBoxDimensions readBoxDimensions( final LexicalUnit unit ) {
     QxBoxDimensions result = null;
     Integer value1 = readSingleLengthUnit( unit );
     if( value1 != null ) {
       int top, right, left, bottom;
       top = right = bottom = left = value1.intValue();
       LexicalUnit nextUnit = unit.getNextLexicalUnit();
       boolean ok = true;
       int pos = 1;
       while( nextUnit != null && ok ) {
         pos++;
         Integer nextValue = readSingleLengthUnit( nextUnit );
         ok &= nextValue != null && pos <= 4;
         if( ok ) {
           if( pos == 2 ) {
             right = left = nextValue.intValue();
           } else if( pos == 3 ) {
             bottom = nextValue.intValue();
           } else if( pos == 4 ) {
             left = nextValue.intValue();
           }
         }
         nextUnit = nextUnit.getNextLexicalUnit();
       }
       ok &= nextUnit == null;
       if( ok  ) {
         result = QxBoxDimensions.create( top, right, bottom, left );
       }
     }
     return result;
   }

   public static String readBorderStyle( final LexicalUnit unit ) {
     String result = null;
     short type = unit.getLexicalUnitType();
     if( type == LexicalUnit.SAC_IDENT ) {
       String string = unit.getStringValue();
       if( BORDER_STYLES.contains( string ) ) {
         result = string;
       }
     }
     return result;
   }

   public static int readBorderWidth( final LexicalUnit unit ) {
     int result = -1;
     short type = unit.getLexicalUnitType();
     if( type == LexicalUnit.SAC_IDENT ) {
       String string = unit.getStringValue();
       if( THIN.equals( string ) ) {
         result = THIN_VALUE;
       } else if( MEDIUM.equals( string ) ) {
         result = MEDIUM_VALUE;
       } else if( THICK.equals( string ) ) {
         result = THICK_VALUE;
       }
     } else if( type == LexicalUnit.SAC_PIXEL ) {
       float value = unit.getFloatValue();
       if( value >= 0f ) {
         result = Math.round( value );
       }
     }
     return result;
   }

   public static QxBorder readBorder( final LexicalUnit unit ) {
     QxBorder result = null;
     QxColor color = null;
     String style = null;
     int width = -1;
     LexicalUnit nextUnit = unit;
     boolean consumed = false;
     while( nextUnit != null ) {
       consumed = false;
       if( !consumed && width == -1 ) {
         width = readBorderWidth( nextUnit );
         consumed |= width != -1;
       }
       if( !consumed && style == null ) {
         style = readBorderStyle( nextUnit );
         consumed |= style != null;
       }
       if( !consumed && color == null ) {
         color = readColor( nextUnit );
         consumed |= color != null;
       }
       nextUnit = consumed ? nextUnit.getNextLexicalUnit() : null;
     }
     if( consumed ) {
       // TODO [rst] create should take a QxColor
       result = QxBorder.create( width == -1 ? 0 : width,
                                 style,
                                 color != null ? color.toDefaultString() : null );
     }
     return result;
   }

   public static String readFontStyle( final LexicalUnit unit ) {
     String result = null;
     short type = unit.getLexicalUnitType();
     if( type == LexicalUnit.SAC_IDENT ) {
       String value = unit.getStringValue();
       if( NORMAL.equals( value ) ) {
         result = value;
       } else if( ITALIC.equals( value ) ) {
         result = value;
       }
     }
     return result;
   }

   public static String readFontWeight( final LexicalUnit unit ) {
     String result = null;
     short type = unit.getLexicalUnitType();
     if( type == LexicalUnit.SAC_IDENT ) {
       String value = unit.getStringValue();
       if( NORMAL.equals( value ) ) {
         result = value;
       } else if( BOLD.equals( value ) ) {
         result = value;
       }
     }
     return result;
   }

   public static int readFontSize( final LexicalUnit unit ) {
     int result = -1;
     Integer length = readSingleLengthUnit( unit );
     if( length != null ) {
       int value = length.intValue();
       if( value >= 0 ) {
         result = value;
       }
     }
     return result;
   }

   public static String[] readFontFamily( final LexicalUnit unit ) {
     List list = new ArrayList();
     LexicalUnit nextUnit = unit;
     boolean ok = true;
     String buffer = "";
     while( nextUnit != null && ok ) {
       short type = nextUnit.getLexicalUnitType();
       if( type == LexicalUnit.SAC_STRING_VALUE
           || type == LexicalUnit.SAC_IDENT )
       {
         if( buffer.length() > 0 ) {
           buffer += " ";
         }
         buffer += nextUnit.getStringValue();
       } else if( type == LexicalUnit.SAC_OPERATOR_COMMA ) {
         if( buffer.length() > 0 ) {
           list.add( buffer );
         } else {
           ok = false;
         }
         buffer = "";
       }
       nextUnit = nextUnit.getNextLexicalUnit();
     }
     String[] result = null;
     if( buffer.length() > 0 ) {
       list.add( buffer );
       result = new String[ list.size() ];
       list.toArray( result );
     }
     return result;
   }

   // The format of a URI value is 'url(' followed by optional whitespace
   // followed by an optional single quote (') or double quote (") character
   // followed by the URI itself, followed by an optional single quote (') or
   // double quote (") character followed by optional whitespace followed by ')'.
   // The two quote characters must be the same.

   public static QxFont readFont( final LexicalUnit unit ) {
     QxFont result = null;
     String[] family = null;
     String style = null;
     String weight = null;
     int size = -1;
     boolean consumed = false;
     boolean consumedSize = false;
     boolean consumedFamily = false;
     LexicalUnit nextUnit = unit;
     while( nextUnit != null && !consumedFamily ) {
       consumed = false;
       if( !consumed && !consumedSize && style == null ) {
         style = readFontStyle( nextUnit );
         consumed |= style != null;
       }
       if( !consumed && !consumedSize && weight == null ) {
         weight = readFontWeight( nextUnit );
         consumed |= weight != null;
       }
       if( !consumed && !consumedFamily && size == -1 ) {
         size = readFontSize( nextUnit );
         consumedSize = size != -1;
         consumed |= consumedSize;
       }
       if( !consumed && consumedSize && family == null ) {
         family = readFontFamily( nextUnit );
         consumedFamily = family != null;
         consumed |= consumedFamily;
       }
       nextUnit = consumed ? nextUnit.getNextLexicalUnit() : null;
     }
     if( consumed && consumedSize && consumedFamily ) {
       boolean bold = BOLD.equals( weight );
       boolean italic = ITALIC.equals( style );
       result = QxFont.create( family, size, bold, italic );
     }
     return result;
   }

   public static String readUrl( final LexicalUnit unit ) {
     String result = null;
     short type = unit.getLexicalUnitType();
     if( type == LexicalUnit.SAC_URI ) {
       result = unit.getStringValue();
     }
     return result;
   }

   public static QxImage readBackgroundImage( final LexicalUnit unit,
                                              final ResourceLoader loader ) {
     QxImage result = null;
     short type = unit.getLexicalUnitType();
     if( type == LexicalUnit.SAC_URI ) {
       String value = unit.getStringValue();
       result = QxImage.valueOf( value, loader );
     } else if( type == LexicalUnit.SAC_IDENT ) {
       String value = unit.getStringValue();
       if( NONE.equals( value ) ) {
         result = QxImage.NONE;
       }
     }
     return result;
   }

   private static Integer readSingleLengthUnit( final LexicalUnit unit ) {
     Integer result = null;
     short type = unit.getLexicalUnitType();
     if( type == LexicalUnit.SAC_PIXEL ) {
       result = new Integer( ( int )unit.getFloatValue() );
     }
     return result;
   }

   private static int normalizeRGBValue( final int input ) {
     int result = input;
     if( input < 0 ) {
       result = 0;
     } else if( input > 255 ) {
       result = 255;
     }
     return result;
   }

   private static float normalizePercentValue( final float input ) {
     float result = input;
     if( input < 0f ) {
       result = 0f;
     } else if( input > 100f ) {
       result = 100f;
     }
     return result;
   }

   /*
    * BEGIN Modification for Theme Editor
    * Returns an QxType out of a LexicalUnit.
    */
   public static QxType getQxType( final String cssProperty,
                                   final LexicalUnit unit )
   {
     QxType result = null;
     if( unit != null ) {
 //      IPropertyWrapper wrapper = PropertyWrapperFactory.createPropertyWrapper( cssProperty,
 //                                                                               unit,
 //                                                                               null );
 //      if ( wrapper != null ) {
 //        result = wrapper.getQxType();
 //      }
     }
     return result;
   }

   /*
    * Returns the color value of a border unit.
    */
   public static QxColor readBorderColor( final LexicalUnit unit ) {
     QxColor result = null;
     String style = null;
     int width = -1;
     LexicalUnit nextUnit = unit;
     boolean consumed = false;
     while( nextUnit != null ) {
       consumed = false;
       if( !consumed && width == -1 ) {
         width = readBorderWidth( nextUnit );
         consumed |= width != -1;
       }
       if( !consumed && style == null ) {
         style = readBorderStyle( nextUnit );
         consumed |= style != null;
       }
       if( !consumed && result == null ) {
         result = readColor( nextUnit );
         consumed |= result != null;
       }
       nextUnit = consumed
                          ? nextUnit.getNextLexicalUnit()
                          : null;
     }
     return result;
   }
   /*
    * END Modification for Theme Editor
    */
 }
	/*******************************************************************************
	* Copyright (c) 2008 Innoopract Informationssysteme GmbH.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	* Contributors:
	* Innoopract Informationssysteme GmbH - initial API and implementation
	******************************************************************************/

	package org.eclipse.rwt.internal.theme.css;

	import java.util.*;

	import org.eclipse.rwt.internal.theme.*;

	import org.w3c.css.sac.LexicalUnit;


	public class PropertyResolver {

	private static final String BOLD = "bold";

	private static final String ITALIC = "italic";

	private static final String NORMAL = "normal";

	private static final String NONE = "none";

	private static final String HIDDEN = "hidden";

	private static final String DOTTED = "dotted";

	private static final String DASHED = "dashed";

	private static final String SOLID = "solid";

	private static final String DOUBLE = "double";

	private static final String GROOVE = "groove";

	private static final String RIDGE = "ridge";

	private static final String INSET = "inset";

	private static final String OUTSET = "outset";

	/** A thin border. */
	private static final String THIN = "thin";

	/** A medium border. */
	private static final String MEDIUM = "medium";

	/** A thick border. */
	private static final String THICK = "thick";

	private static final String TRANSPARENT = "transparent";

	private static final Map NAMED_COLORS = new HashMap();

	private static final List BORDER_STYLES = new ArrayList();

	/** Width value for "thin" identifier. */
	public static final int THIN_VALUE = 1;

	/** Width value for "medium" identifier. */
	public static final int MEDIUM_VALUE = 3;

	/** Width value for "thick" identifier. */
	public static final int THICK_VALUE = 5;

	static {
	// register 16 standard HTML colors
	NAMED_COLORS.put( "black", new int[] { 0, 0, 0 } );
	NAMED_COLORS.put( "gray", new int[] { 128, 128, 128 } );
	NAMED_COLORS.put( "silver", new int[] { 192, 192, 192 } );
	NAMED_COLORS.put( "white", new int[] { 255, 255, 255 } );
	NAMED_COLORS.put( "maroon", new int[] { 128, 0, 0 } );
	NAMED_COLORS.put( "red", new int[] { 255, 0, 0 } );
	NAMED_COLORS.put( "purple", new int[] { 128, 0, 128 } );
	NAMED_COLORS.put( "fuchsia", new int[] { 255, 0, 255 } );
	NAMED_COLORS.put( "green", new int[] { 0, 128, 0 } );
	NAMED_COLORS.put( "lime", new int[] { 0, 255, 0 } );
	NAMED_COLORS.put( "navy", new int[] { 0, 0, 128 } );
	NAMED_COLORS.put( "blue", new int[] { 0, 0, 255 } );
	NAMED_COLORS.put( "olive", new int[] { 128, 128, 0 } );
	NAMED_COLORS.put( "yellow", new int[] { 255, 255, 0 } );
	NAMED_COLORS.put( "teal", new int[] { 0, 128, 128 } );
	NAMED_COLORS.put( "aqua", new int[] { 0, 255, 255 } );
	// register border styles
	BORDER_STYLES.add( NONE ); // No border; the computed border width is zero.
	BORDER_STYLES.add( HIDDEN ); // Same as 'none', except in terms of border conflict resolution for table elements.
	BORDER_STYLES.add( DOTTED ); // The border is a series of dots.
	BORDER_STYLES.add( DASHED ); // The border is a series of short line segments.
	BORDER_STYLES.add( SOLID ); // The border is a single line segment.
	BORDER_STYLES.add( DOUBLE ); // The border is two solid lines. The sum of the two lines and the space between them equals the value of 'border-width'.
	BORDER_STYLES.add( GROOVE ); // The border looks as though it were carved into the canvas.
	BORDER_STYLES.add( RIDGE ); // The opposite of 'groove': the border looks as though it were coming out of the canvas.
	BORDER_STYLES.add( INSET ); // The border makes the box look as though it were embedded in the canvas.
	BORDER_STYLES.add( OUTSET ); // The opposite of 'inset': the border makes the box look as though it were coming out of the canvas.
	}

	public static QxColor readColor( final LexicalUnit input ) {
	QxColor result = null;
	short type = input.getLexicalUnitType();
	if( type == LexicalUnit.SAC_RGBCOLOR ) {
	LexicalUnit redParam = input.getParameters();
	LexicalUnit greenParam = redParam.getNextLexicalUnit().getNextLexicalUnit();
	LexicalUnit blueParam = greenParam.getNextLexicalUnit().getNextLexicalUnit();
	short valueType = redParam.getLexicalUnitType();
	if( greenParam.getLexicalUnitType() == valueType
	\|\| blueParam.getLexicalUnitType() == valueType )
	{
	if( valueType == LexicalUnit.SAC_INTEGER ) {
	int red = normalizeRGBValue( redParam.getIntegerValue() );
	int green = normalizeRGBValue( greenParam.getIntegerValue() );
	int blue = normalizeRGBValue( blueParam.getIntegerValue() );
	result = QxColor.create( red, green, blue );
	} else if( valueType == LexicalUnit.SAC_PERCENTAGE ) {
	float redPercent = normalizePercentValue( redParam.getFloatValue() );
	float greenPercent = normalizePercentValue( greenParam.getFloatValue() );
	float bluePercent = normalizePercentValue( blueParam.getFloatValue() );
	int red = ( int )( 255 * redPercent / 100 );
	int green = ( int )( 255 * greenPercent / 100 );
	int blue = ( int )( 255 * bluePercent / 100 );
	result = QxColor.create( red, green, blue );
	}
	}
	} else if( type == LexicalUnit.SAC_IDENT ) {
	String string = input.getStringValue();
	if( TRANSPARENT.equals( string ) ) {
	result = QxColor.TRANSPARENT;
	} else if( NAMED_COLORS.containsKey( string.toLowerCase() ) ) {
	int[] values = ( int[] )NAMED_COLORS.get( string.toLowerCase() );
	result = QxColor.create( values[ 0 ], values[ 1 ], values[ 2 ] );
	}
	}
	return result;
	}

	public static QxDimension readDimension( final LexicalUnit unit ) {
	QxDimension result = null;
	Integer length = readSingleLengthUnit( unit );
	if( length != null ) {
	result = QxDimension.create( length.intValue() );
	}
	return result;
	}

	public static QxBoxDimensions readBoxDimensions( final LexicalUnit unit ) {
	QxBoxDimensions result = null;
	Integer value1 = readSingleLengthUnit( unit );
	if( value1 != null ) {
	int top, right, left, bottom;
	top = right = bottom = left = value1.intValue();
	LexicalUnit nextUnit = unit.getNextLexicalUnit();
	boolean ok = true;
	int pos = 1;
	while( nextUnit != null && ok ) {
	pos++;
	Integer nextValue = readSingleLengthUnit( nextUnit );
	ok &= nextValue != null && pos <= 4;
	if( ok ) {
	if( pos == 2 ) {
	right = left = nextValue.intValue();
	} else if( pos == 3 ) {
	bottom = nextValue.intValue();
	} else if( pos == 4 ) {
	left = nextValue.intValue();
	}
	}
	nextUnit = nextUnit.getNextLexicalUnit();
	}
	ok &= nextUnit == null;
	if( ok ) {
	result = QxBoxDimensions.create( top, right, bottom, left );
	}
	}
	return result;
	}

	public static String readBorderStyle( final LexicalUnit unit ) {
	String result = null;
	short type = unit.getLexicalUnitType();
	if( type == LexicalUnit.SAC_IDENT ) {
	String string = unit.getStringValue();
	if( BORDER_STYLES.contains( string ) ) {
	result = string;
	}
	}
	return result;
	}

	public static int readBorderWidth( final LexicalUnit unit ) {
	int result = -1;
	short type = unit.getLexicalUnitType();
	if( type == LexicalUnit.SAC_IDENT ) {
	String string = unit.getStringValue();
	if( THIN.equals( string ) ) {
	result = THIN_VALUE;
	} else if( MEDIUM.equals( string ) ) {
	result = MEDIUM_VALUE;
	} else if( THICK.equals( string ) ) {
	result = THICK_VALUE;
	}
	} else if( type == LexicalUnit.SAC_PIXEL ) {
	float value = unit.getFloatValue();
	if( value >= 0f ) {
	result = Math.round( value );
	}
	}
	return result;
	}

	public static QxBorder readBorder( final LexicalUnit unit ) {
	QxBorder result = null;
	QxColor color = null;
	String style = null;
	int width = -1;
	LexicalUnit nextUnit = unit;
	boolean consumed = false;
	while( nextUnit != null ) {
	consumed = false;
	if( !consumed && width == -1 ) {
	width = readBorderWidth( nextUnit );
	consumed \|= width != -1;
	}
	if( !consumed && style == null ) {
	style = readBorderStyle( nextUnit );
	consumed \|= style != null;
	}
	if( !consumed && color == null ) {
	color = readColor( nextUnit );
	consumed \|= color != null;
	}
	nextUnit = consumed ? nextUnit.getNextLexicalUnit() : null;
	}
	if( consumed ) {
	// TODO [rst] create should take a QxColor
	result = QxBorder.create( width == -1 ? 0 : width,
	style,
	color != null ? color.toDefaultString() : null );
	}
	return result;
	}

	public static String readFontStyle( final LexicalUnit unit ) {
	String result = null;
	short type = unit.getLexicalUnitType();
	if( type == LexicalUnit.SAC_IDENT ) {
	String value = unit.getStringValue();
	if( NORMAL.equals( value ) ) {
	result = value;
	} else if( ITALIC.equals( value ) ) {
	result = value;
	}
	}
	return result;
	}

	public static String readFontWeight( final LexicalUnit unit ) {
	String result = null;
	short type = unit.getLexicalUnitType();
	if( type == LexicalUnit.SAC_IDENT ) {
	String value = unit.getStringValue();
	if( NORMAL.equals( value ) ) {
	result = value;
	} else if( BOLD.equals( value ) ) {
	result = value;
	}
	}
	return result;
	}

	public static int readFontSize( final LexicalUnit unit ) {
	int result = -1;
	Integer length = readSingleLengthUnit( unit );
	if( length != null ) {
	int value = length.intValue();
	if( value >= 0 ) {
	result = value;
	}
	}
	return result;
	}

	public static String[] readFontFamily( final LexicalUnit unit ) {
	List list = new ArrayList();
	LexicalUnit nextUnit = unit;
	boolean ok = true;
	String buffer = "";
	while( nextUnit != null && ok ) {
	short type = nextUnit.getLexicalUnitType();
	if( type == LexicalUnit.SAC_STRING_VALUE
	\|\| type == LexicalUnit.SAC_IDENT )
	{
	if( buffer.length() > 0 ) {
	buffer += " ";
	}
	buffer += nextUnit.getStringValue();
	} else if( type == LexicalUnit.SAC_OPERATOR_COMMA ) {
	if( buffer.length() > 0 ) {
	list.add( buffer );
	} else {
	ok = false;
	}
	buffer = "";
	}
	nextUnit = nextUnit.getNextLexicalUnit();
	}
	String[] result = null;
	if( buffer.length() > 0 ) {
	list.add( buffer );
	result = new String[ list.size() ];
	list.toArray( result );
	}
	return result;
	}

	// The format of a URI value is 'url(' followed by optional whitespace
	// followed by an optional single quote (') or double quote (") character
	// followed by the URI itself, followed by an optional single quote (') or
	// double quote (") character followed by optional whitespace followed by ')'.
	// The two quote characters must be the same.

	public static QxFont readFont( final LexicalUnit unit ) {
	QxFont result = null;
	String[] family = null;
	String style = null;
	String weight = null;
	int size = -1;
	boolean consumed = false;
	boolean consumedSize = false;
	boolean consumedFamily = false;
	LexicalUnit nextUnit = unit;
	while( nextUnit != null && !consumedFamily ) {
	consumed = false;
	if( !consumed && !consumedSize && style == null ) {
	style = readFontStyle( nextUnit );
	consumed \|= style != null;
	}
	if( !consumed && !consumedSize && weight == null ) {
	weight = readFontWeight( nextUnit );
	consumed \|= weight != null;
	}
	if( !consumed && !consumedFamily && size == -1 ) {
	size = readFontSize( nextUnit );
	consumedSize = size != -1;
	consumed \|= consumedSize;
	}
	if( !consumed && consumedSize && family == null ) {
	family = readFontFamily( nextUnit );
	consumedFamily = family != null;
	consumed \|= consumedFamily;
	}
	nextUnit = consumed ? nextUnit.getNextLexicalUnit() : null;
	}
	if( consumed && consumedSize && consumedFamily ) {
	boolean bold = BOLD.equals( weight );
	boolean italic = ITALIC.equals( style );
	result = QxFont.create( family, size, bold, italic );
	}
	return result;
	}

	public static String readUrl( final LexicalUnit unit ) {
	String result = null;
	short type = unit.getLexicalUnitType();
	if( type == LexicalUnit.SAC_URI ) {
	result = unit.getStringValue();
	}
	return result;
	}

	public static QxImage readBackgroundImage( final LexicalUnit unit,
	final ResourceLoader loader ) {
	QxImage result = null;
	short type = unit.getLexicalUnitType();
	if( type == LexicalUnit.SAC_URI ) {
	String value = unit.getStringValue();
	result = QxImage.valueOf( value, loader );
	} else if( type == LexicalUnit.SAC_IDENT ) {
	String value = unit.getStringValue();
	if( NONE.equals( value ) ) {
	result = QxImage.NONE;
	}
	}
	return result;
	}

	private static Integer readSingleLengthUnit( final LexicalUnit unit ) {
	Integer result = null;
	short type = unit.getLexicalUnitType();
	if( type == LexicalUnit.SAC_PIXEL ) {
	result = new Integer( ( int )unit.getFloatValue() );
	}
	return result;
	}

	private static int normalizeRGBValue( final int input ) {
	int result = input;
	if( input < 0 ) {
	result = 0;
	} else if( input > 255 ) {
	result = 255;
	}
	return result;
	}

	private static float normalizePercentValue( final float input ) {
	float result = input;
	if( input < 0f ) {
	result = 0f;
	} else if( input > 100f ) {
	result = 100f;
	}
	return result;
	}

	/*
	* BEGIN Modification for Theme Editor
	* Returns an QxType out of a LexicalUnit.
	*/
	public static QxType getQxType( final String cssProperty,
	final LexicalUnit unit )
	{
	QxType result = null;
	if( unit != null ) {
	// IPropertyWrapper wrapper = PropertyWrapperFactory.createPropertyWrapper( cssProperty,
	// unit,
	// null );
	// if ( wrapper != null ) {
	// result = wrapper.getQxType();
	// }
	}
	return result;
	}

	/*
	* Returns the color value of a border unit.
	*/
	public static QxColor readBorderColor( final LexicalUnit unit ) {
	QxColor result = null;
	String style = null;
	int width = -1;
	LexicalUnit nextUnit = unit;
	boolean consumed = false;
	while( nextUnit != null ) {
	consumed = false;
	if( !consumed && width == -1 ) {
	width = readBorderWidth( nextUnit );
	consumed \|= width != -1;
	}
	if( !consumed && style == null ) {
	style = readBorderStyle( nextUnit );
	consumed \|= style != null;
	}
	if( !consumed && result == null ) {
	result = readColor( nextUnit );
	consumed \|= result != null;
	}
	nextUnit = consumed
	? nextUnit.getNextLexicalUnit()
	: null;
	}
	return result;
	}
	/*
	* END Modification for Theme Editor
	*/
	}