| /* |
| * |
| * 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 flash.css; |
| |
| import flash.util.Trace; |
| import flex2.compiler.util.CompilerMessage.CompilerError; |
| import flex2.compiler.util.ThreadLocalToolkit; |
| import org.apache.flex.forks.batik.css.parser.CSSLexicalUnit; |
| import org.w3c.css.sac.LexicalUnit; |
| |
| /** |
| * This class represents a descriptor/property within a CSS rule |
| * declaration. |
| * |
| * @author Peter Farland |
| * @author Paul Reilly |
| */ |
| public class Descriptor |
| { |
| private String name; |
| private LexicalUnit value; |
| private int lineNumber; |
| private String path; |
| |
| public Descriptor(String name, LexicalUnit lexicalUnit, String path) |
| { |
| this.name = name; |
| this.value = lexicalUnit; |
| assert path != null; |
| this.path = path; |
| |
| if (lexicalUnit instanceof CSSLexicalUnit) |
| { |
| lineNumber = ((CSSLexicalUnit) lexicalUnit).getLineNumber(); |
| } |
| } |
| |
| /** |
| * Converts one of the sixteen colors defined in |
| * http://www.w3.org/TR/REC-html40/types.html#h-6.5 to the |
| * 0x000000 format. |
| */ |
| public static String convertColorName(String color) |
| { |
| if (color.length() != 0) |
| { |
| switch (color.charAt(0)) |
| { |
| case 'b': case 'B': |
| if (color.equalsIgnoreCase("black")) |
| { |
| return "0x000000"; |
| } |
| if (color.equalsIgnoreCase("blue")) |
| { |
| return "0x0000FF"; |
| } |
| break; |
| case 'g': case 'G': |
| if (color.equalsIgnoreCase("green")) |
| { |
| return "0x008000"; |
| } |
| if (color.equalsIgnoreCase("gray")) |
| { |
| return "0x808080"; |
| } |
| break; |
| case 's': case 'S': |
| if (color.equalsIgnoreCase("silver")) |
| { |
| return "0xC0C0C0"; |
| } |
| break; |
| case 'l': case 'L': |
| if (color.equalsIgnoreCase("lime")) |
| { |
| return "0x00FF00"; |
| } |
| break; |
| case 'o': case 'O': |
| if (color.equalsIgnoreCase("olive")) |
| { |
| return "0x808000"; |
| } |
| break; |
| case 'w': case 'W': |
| if (color.equalsIgnoreCase("white")) |
| { |
| return "0xFFFFFF"; |
| } |
| break; |
| case 'y': case 'Y': |
| if (color.equalsIgnoreCase("yellow")) |
| { |
| return "0xFFFF00"; |
| } |
| break; |
| case 'm': case 'M': |
| if (color.equalsIgnoreCase("maroon")) |
| { |
| return "0x800000"; |
| } |
| if (color.equalsIgnoreCase("magenta")) |
| { |
| // nonstandard color used by appmodel. See mx.styles.StyleManager.colorNames[] |
| return "0xFF00FF"; |
| } |
| break; |
| case 'n': case 'N': |
| if (color.equalsIgnoreCase("navy")) |
| { |
| return "0x000080"; |
| } |
| break; |
| case 'r': case 'R': |
| if (color.equalsIgnoreCase("red")) |
| { |
| return "0xFF0000"; |
| } |
| break; |
| case 'p': case 'P': |
| if (color.equalsIgnoreCase("purple")) |
| { |
| return "0x800080"; |
| } |
| break; |
| case 't': case 'T': |
| if (color.equalsIgnoreCase("teal")) |
| { |
| return "0x008080"; |
| } |
| break; |
| case 'f': case 'F': |
| if (color.equalsIgnoreCase("fuchsia")) |
| { |
| return "0xFF00FF"; |
| } |
| break; |
| case 'a': case 'A': |
| if (color.equalsIgnoreCase("aqua")) |
| { |
| return "0x00FFFF"; |
| } |
| break; |
| case 'c': case 'C': |
| if (color.equalsIgnoreCase("cyan")) |
| { |
| // nonstandard color used by appmodel. See mx.styles.StyleManager.colorNames[] |
| return "0x00FFFF"; |
| } |
| break; |
| case 'h': case 'H': |
| // |
| // IMPORTANT: Theme colors must be updated in the following places: |
| // 1). In _global.style (near the top of Defaults.as) |
| // 2). In function setThemeStyle (near the bottom of Defaults.as) |
| // 3). In StyleManager colorNames (in the middle of StyleManager.as) |
| // 4). In the Flex compiler CSS parser (in \src\java\macromedia\css\Descriptor.java) |
| // |
| if (color.equalsIgnoreCase("haloGreen")) |
| { |
| // nonstandard color used by appmodel. See mx.styles.StyleManager.colorNames[] |
| return "0x80FF4D"; |
| } |
| if (color.equalsIgnoreCase("haloBlue")) |
| { |
| // nonstandard color used by appmodel. See mx.styles.StyleManager.colorNames[] |
| return "0x009DFF"; |
| } |
| if (color.equalsIgnoreCase("haloOrange")) |
| { |
| // nonstandard color used by appmodel. See mx.styles.StyleManager.colorNames[] |
| return "0xFFB600"; |
| } |
| if (color.equalsIgnoreCase("haloSilver")) |
| { |
| // nonstandard color used by appmodel. See mx.styles.StyleManager.colorNames[] |
| return "0xAECAD9"; |
| } |
| break; |
| } |
| } |
| |
| return null; |
| } |
| |
| public String getName() |
| { |
| return name; |
| } |
| |
| public LexicalUnit getValue() |
| { |
| return value; |
| } |
| |
| public String getIdentAsString() |
| { |
| StringBuilder sb = new StringBuilder(); |
| LexicalUnit lexicalUnit = value; |
| |
| while (lexicalUnit != null) |
| { |
| try |
| { |
| switch(lexicalUnit.getLexicalUnitType()) |
| { |
| case LexicalUnit.SAC_IDENT: |
| sb.append(lexicalUnit.getStringValue()); |
| break; |
| case LexicalUnit.SAC_OPERATOR_COMMA: |
| sb.append(','); |
| break; |
| case LexicalUnit.SAC_INTEGER: |
| sb.append(lexicalUnit.getIntegerValue()); |
| break; |
| default: |
| sb.append(lexicalUnit.getStringValue()); |
| break; |
| } |
| } |
| catch(IllegalStateException ise) |
| { |
| UnparsableCSS unparsableCSS = new UnparsableCSS(); |
| unparsableCSS.path = path; |
| unparsableCSS.line = lineNumber; |
| ThreadLocalToolkit.log(unparsableCSS); |
| } |
| |
| lexicalUnit = lexicalUnit.getNextLexicalUnit(); |
| } |
| |
| return sb.toString(); |
| } |
| |
| public String getColorAsString() throws CompilerError |
| { |
| return getColorAsString(name, value); |
| } |
| |
| private static String getColorAsString(String name, LexicalUnit lexicalUnit) throws CompilerError |
| { |
| String color; |
| |
| short type = lexicalUnit.getLexicalUnitType(); |
| |
| switch(type) |
| { |
| case LexicalUnit.SAC_IDENT: |
| { |
| color = convertColorName( lexicalUnit.getStringValue() ); |
| |
| if (color == null) |
| { |
| throw new ColorNotSupported(lexicalUnit.getStringValue()); |
| } |
| |
| break; |
| } |
| case LexicalUnit.SAC_RGBCOLOR: |
| { |
| StringBuilder stringBuffer = new StringBuilder("0x"); |
| |
| LexicalUnit parameter = lexicalUnit.getParameters(); |
| |
| while (parameter != null) |
| { |
| int digit; |
| |
| switch(parameter.getLexicalUnitType()) |
| { |
| case LexicalUnit.SAC_INTEGER: |
| { |
| digit = parameter.getIntegerValue(); |
| stringBuffer.append(Character.forDigit((digit >> 4) & 15, 16)); |
| stringBuffer.append(Character.forDigit(digit & 15, 16)); |
| break; |
| } |
| case LexicalUnit.SAC_PERCENTAGE: |
| { |
| digit = ((new Float(parameter.getFloatValue())).intValue() * 255) / 100; |
| stringBuffer.append(Character.forDigit((digit >> 4) & 15, 16)); |
| stringBuffer.append(Character.forDigit(digit & 15, 16)); |
| break; |
| } |
| } |
| |
| parameter = parameter.getNextLexicalUnit(); |
| } |
| |
| color = stringBuffer.toString(); |
| break; |
| } |
| default: |
| { |
| if (Trace.css) |
| { |
| Trace.trace("Descriptor.getColorAsString: type = " + type); |
| } |
| throw new ValueNotSupported(name); |
| } |
| } |
| |
| return color; |
| } |
| |
| public String getLengthAsString() throws CompilerError |
| { |
| return getLengthAsString(name, value); |
| } |
| |
| private static String getLengthAsString(String name, LexicalUnit lexicalUnit) |
| throws CompilerError |
| { |
| float length; |
| |
| short type = lexicalUnit.getLexicalUnitType(); |
| |
| switch(type) |
| { |
| case LexicalUnit.SAC_CENTIMETER: |
| { |
| length = (lexicalUnit.getFloatValue() * 72) / 2.54F; |
| break; |
| } |
| case LexicalUnit.SAC_MILLIMETER: |
| { |
| length = ((lexicalUnit.getFloatValue() * 72) / 10) / 2.54F; |
| break; |
| } |
| case LexicalUnit.SAC_INCH: |
| { |
| length = lexicalUnit.getFloatValue() * 72; |
| break; |
| } |
| case LexicalUnit.SAC_PICA: |
| { |
| length = lexicalUnit.getFloatValue() * 12; |
| break; |
| } |
| case LexicalUnit.SAC_PIXEL: |
| { |
| length = lexicalUnit.getFloatValue(); |
| break; |
| } |
| case LexicalUnit.SAC_POINT: |
| { |
| length = lexicalUnit.getFloatValue(); |
| break; |
| } |
| case LexicalUnit.SAC_IDENT: |
| { |
| String absoluteSize = lexicalUnit.getStringValue(); |
| |
| if ( absoluteSize.equalsIgnoreCase("xx-small") ) |
| { |
| length = 7; // (12 / 1.2 / 1.2 / 1.2) |
| } |
| else if ( absoluteSize.equalsIgnoreCase("x-small") ) |
| { |
| length = 8; // (12 / 1.2 / 1.2) |
| } |
| else if ( absoluteSize.equalsIgnoreCase("small") ) |
| { |
| length = 10; // (12 / 1.2) |
| } |
| else if ( absoluteSize.equalsIgnoreCase("medium") ) |
| { |
| length = 12; |
| } |
| else if ( absoluteSize.equalsIgnoreCase("large") ) |
| { |
| length = 14; // (12 * 1.2) |
| } |
| else if ( absoluteSize.equalsIgnoreCase("x-large") ) |
| { |
| length = 17; // (12 * 1.2 * 1.2) |
| } |
| else if ( absoluteSize.equalsIgnoreCase("xx-large") ) |
| { |
| length = 21; // (12 * 1.2 * 1.2 * 1.2) |
| } |
| else |
| { |
| throw new ValueNotSupported(name); |
| } |
| break; |
| } |
| default: |
| { |
| if (Trace.css) |
| { |
| Trace.trace("Descriptor.getLengthAsString: type = " + type); |
| } |
| throw new ValueNotSupported(name); |
| } |
| } |
| |
| return Integer.toString(((new Float(length)).intValue())); |
| } |
| |
| public int getLineNumber() |
| { |
| return lineNumber; |
| } |
| |
| private static String getListAsString(String name, LexicalUnit value) |
| throws CompilerError |
| { |
| return getListAsString(name, value, true); |
| } |
| |
| private static String getListAsString(String name, LexicalUnit value, boolean quoteIdentifier) |
| throws CompilerError |
| { |
| StringBuilder stringBuffer = new StringBuilder(); |
| |
| LexicalUnit current = value; |
| |
| while (current != null) |
| { |
| stringBuffer.append( getLexicalUnitAsString(name, current, quoteIdentifier) ); |
| |
| LexicalUnit next = current.getNextLexicalUnit(); |
| |
| if (next != null) |
| { |
| if (next.getLexicalUnitType() == LexicalUnit.SAC_OPERATOR_COMMA) |
| { |
| current = next.getNextLexicalUnit(); |
| stringBuffer.append(", "); |
| } |
| else if (next.getLexicalUnitType() == LexicalUnit.SAC_OPERATOR_SLASH) |
| { |
| current = next.getNextLexicalUnit(); |
| stringBuffer.append(" = "); |
| } |
| else |
| { |
| throw new InvalidFormat(); |
| } |
| } |
| else |
| { |
| current = null; |
| } |
| } |
| |
| return stringBuffer.toString(); |
| } |
| |
| public String getPath() |
| { |
| return path; |
| } |
| |
| public String getTimeAsString() throws CompilerError |
| { |
| return getTimeAsString(name, value); |
| } |
| |
| private static String getTimeAsString(String name, LexicalUnit lexicalUnit) |
| throws CompilerError |
| { |
| float time; |
| |
| short type = lexicalUnit.getLexicalUnitType(); |
| |
| switch(type) |
| { |
| case LexicalUnit.SAC_MILLISECOND: |
| { |
| time = lexicalUnit.getFloatValue(); |
| break; |
| } |
| case LexicalUnit.SAC_SECOND: |
| { |
| time = lexicalUnit.getFloatValue() * 60; |
| break; |
| } |
| default: |
| { |
| if (Trace.css) |
| { |
| Trace.trace("Descriptor.getTimeAsString: type = " + type); |
| } |
| throw new ValueNotSupported(name); |
| } |
| } |
| |
| return Integer.toString(((new Float(time)).intValue())); |
| } |
| |
| /** |
| * This method should be used to get the string value of a |
| * Descriptor, when the format isn't already known. |
| */ |
| public String getValueAsString() throws CompilerError |
| { |
| String valueString; |
| |
| LexicalUnit next = value.getNextLexicalUnit(); |
| |
| if ((next != null) && (next.getLexicalUnitType() == LexicalUnit.SAC_OPERATOR_COMMA)) |
| { |
| valueString = ("[" + getListAsString(name, value) + "]"); |
| } |
| else |
| { |
| valueString = getLexicalUnitAsString(name, value); |
| } |
| |
| return valueString; |
| } |
| |
| private static String getLexicalUnitAsString(String name, LexicalUnit lexicalUnit) |
| throws CompilerError |
| { |
| return getLexicalUnitAsString(name, lexicalUnit, true); |
| } |
| |
| private static String getLexicalUnitAsString(String name, |
| LexicalUnit lexicalUnit, |
| boolean quoteIdentifier) |
| throws CompilerError |
| { |
| String result; |
| |
| short type = lexicalUnit.getLexicalUnitType(); |
| |
| switch(type) |
| { |
| case LexicalUnit.SAC_MILLISECOND: |
| case LexicalUnit.SAC_SECOND: |
| { |
| result = getTimeAsString(name, lexicalUnit); |
| break; |
| } |
| case LexicalUnit.SAC_CENTIMETER: |
| case LexicalUnit.SAC_MILLIMETER: |
| case LexicalUnit.SAC_INCH: |
| case LexicalUnit.SAC_PICA: |
| case LexicalUnit.SAC_POINT: |
| case LexicalUnit.SAC_PIXEL: |
| { |
| result = getLengthAsString(name, lexicalUnit); |
| break; |
| } |
| case LexicalUnit.SAC_RGBCOLOR: |
| { |
| result = getColorAsString(name, lexicalUnit); |
| break; |
| } |
| case LexicalUnit.SAC_INTEGER: |
| { |
| result = Integer.toString( lexicalUnit.getIntegerValue() ); |
| break; |
| } |
| case LexicalUnit.SAC_REAL: |
| { |
| result = Float.toString( lexicalUnit.getFloatValue() ); |
| break; |
| } |
| case LexicalUnit.SAC_STRING_VALUE: |
| case LexicalUnit.SAC_URI: |
| { |
| result = "\"" + lexicalUnit.getStringValue().replace('\"', '\'') + "\""; |
| break; |
| } |
| case LexicalUnit.SAC_IDENT: |
| { |
| // This could be a color, absolute size, or just a |
| // plain identifier, so try each in that order. |
| try |
| { |
| result = getColorAsString(name, lexicalUnit); |
| } |
| catch (CompilerError compilerError) |
| { |
| try |
| { |
| result = getLengthAsString(name, lexicalUnit); |
| } |
| catch (CompilerError compilerError2) |
| { |
| String stringValue = lexicalUnit.getStringValue(); |
| |
| if (stringValue.equalsIgnoreCase(Boolean.FALSE.toString()) || |
| stringValue.equalsIgnoreCase(Boolean.TRUE.toString())) |
| { |
| result = stringValue; |
| } |
| else if (quoteIdentifier) |
| { |
| // preilly: Don't use getIdentAsString() here, see bug 86974. |
| result = "\"" + stringValue.replace('\"', '\'') + "\""; |
| } |
| else |
| { |
| result = stringValue; |
| } |
| } |
| } |
| break; |
| } |
| case LexicalUnit.SAC_FUNCTION: |
| { |
| String functionName = lexicalUnit.getFunctionName(); |
| if (functionName.equals("Embed") || |
| functionName.equals("ClassReference") || |
| functionName.equals("PropertyReference")) |
| { |
| result = functionName + "(" + getListAsString(null, lexicalUnit.getParameters(), false) + ")"; |
| } |
| else |
| { |
| throw new FunctionNotSupported(functionName); |
| } |
| break; |
| } |
| default: |
| { |
| if (Trace.css) |
| { |
| Trace.trace("Descriptor.getLexicalUnitAsString: type = " + type); |
| } |
| throw new ValueNotSupported(name); |
| } |
| } |
| |
| return result; |
| } |
| |
| public static class ColorNotSupported extends CompilerError |
| { |
| private static final long serialVersionUID = -9167022814274170798L; |
| public String color; |
| |
| public ColorNotSupported(String color) |
| { |
| this.color = color; |
| } |
| } |
| |
| public static class InvalidFormat extends CompilerError |
| { |
| |
| private static final long serialVersionUID = 8620593353408269587L; |
| } |
| |
| public static class UnparsableCSS extends CompilerError |
| { |
| |
| private static final long serialVersionUID = -8939846058668804295L; |
| } |
| |
| public static class ValueNotSupported extends CompilerError |
| { |
| private static final long serialVersionUID = 657854378435002555L; |
| public String value; |
| |
| public ValueNotSupported(String value) |
| { |
| this.value = value; |
| } |
| } |
| |
| public static class FunctionNotSupported extends CompilerError |
| { |
| private static final long serialVersionUID = -7607804535214540281L; |
| public String function; |
| |
| public FunctionNotSupported(String function) |
| { |
| this.function = function; |
| } |
| } |
| } |
