| /******************************************************************************* |
| * 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.ArrayList; |
| import java.util.List; |
| |
| import org.w3c.css.sac.*; |
| |
| |
| public class DocumentHandlerImpl implements DocumentHandler, DocumentHandlerExt { |
| |
| private String uri; |
| private final List rules; |
| private final CssFileReader reader; |
| private StylePropertyMap currentStyleProperties = null; |
| |
| /* BEGIN Modification for Theme Editor */ |
| private int ruleLineNumber = -1; |
| private List comments = new ArrayList(); |
| private boolean firstSelectorStarted = false; |
| private boolean insideRule = false; |
| private String headerComment; |
| |
| public String getHeaderComment() { |
| return headerComment; |
| } |
| /* END Modification for Theme Editor */ |
| |
| public DocumentHandlerImpl( final CssFileReader reader ) { |
| this.reader = reader; |
| this.rules = new ArrayList(); |
| } |
| |
| public void startDocument( final InputSource source ) throws CSSException { |
| uri = source.getURI(); |
| log( "=== startDocument " + uri + "===" ); |
| } |
| |
| public void endDocument( final InputSource source ) throws CSSException { |
| log( "___ endDocument ___" ); |
| } |
| |
| public void startSelector( final SelectorList patterns ) throws CSSException { |
| log( "startSelector " + toString( patterns ) ); |
| currentStyleProperties = new StylePropertyMap(); |
| /* BEGIN Modification for Theme Editor */ |
| ruleLineNumber = reader.getCurrentLine() - 1; |
| firstSelectorStarted = true; |
| insideRule = true; |
| /* END Modification for Theme Editor */ |
| } |
| |
| public void endSelector( final SelectorList patterns ) throws CSSException { |
| log( "endSelector " + toString( patterns ) ); |
| /* BEGIN Modification for Theme Editor */ |
| StyleRule newRule = new StyleRule( patterns, currentStyleProperties ); |
| newRule.setComments( comments ); |
| newRule.setLineNumber( ruleLineNumber ); |
| rules.add( newRule ); |
| comments = new ArrayList(); |
| insideRule = false; |
| /* END Modification for Theme Editor */ |
| currentStyleProperties = null; |
| } |
| |
| public void property( final String name, |
| final LexicalUnit value, |
| final boolean important ) throws CSSException |
| { |
| log( " property " |
| + name |
| + " := " |
| + toString( value ) |
| + ( important |
| ? ", important" |
| : "" ) ); |
| if( currentStyleProperties != null ) { |
| currentStyleProperties.setProperty( name, value ); |
| } |
| } |
| |
| /* BEGIN Modification for Theme Editor */ |
| public void propertyString( final String name, final String value ) { |
| if( currentStyleProperties != null ) { |
| currentStyleProperties.setPropertyString( name, value ); |
| } |
| } |
| |
| public void propertyLine( final String name, final int line ) { |
| if( currentStyleProperties != null ) { |
| currentStyleProperties.setLineNumber( name, line ); |
| } |
| } |
| /* END Modification for Theme Editor */ |
| |
| // -- ignored, but used for Theme Editor -- |
| public void comment( final String text ) throws CSSException { |
| log( " /*" + text + "*/" ); |
| if ( !insideRule ) { |
| if ( !firstSelectorStarted && headerComment == null ) { |
| headerComment = text; |
| } else { |
| comments.add( text ); |
| } |
| } |
| } |
| |
| // -- unsupported -- |
| public void importStyle( final String uri, |
| final SACMediaList media, |
| final String defaultNamespaceURI ) |
| throws CSSException |
| { |
| log( "importStyle " + uri + ", " + media + ", " + defaultNamespaceURI ); |
| reader.addProblem( new CSSException( "import rules not supported - ignored" ) ); |
| } |
| |
| public void namespaceDeclaration( final String prefix, final String uri ) |
| throws CSSException |
| { |
| log( "namespaceDeclaration " + prefix + ", " + uri ); |
| reader.addProblem( new CSSException( "unsupported namespace declaration '" |
| + prefix |
| + ":" |
| + uri |
| + "' - ignored" ) ); |
| } |
| |
| public void ignorableAtRule( final String atRule ) throws CSSException { |
| log( "ignorableAtRule " + atRule ); |
| reader.addProblem( new CSSException( "unsupported at rule '" |
| + atRule |
| + "' - ignored" ) ); |
| } |
| |
| public void startPage( final String name, final String pseudo_page ) |
| throws CSSException |
| { |
| log( "startPage " + name + ", " + pseudo_page ); |
| reader.addProblem( new CSSException( "page rules not supported - ignored" ) ); |
| } |
| |
| public void endPage( final String name, final String pseudo_page ) |
| throws CSSException |
| { |
| log( "endPage " + name + ", " + pseudo_page ); |
| } |
| |
| public void startMedia( final SACMediaList media ) throws CSSException { |
| log( "startMedia " + media ); |
| reader.addProblem( new CSSException( "media rules not supported - ignored" ) ); |
| } |
| |
| public void endMedia( final SACMediaList media ) throws CSSException { |
| log( "endMedia " + media ); |
| } |
| |
| public void startFontFace() throws CSSException { |
| log( "startFontFace" ); |
| reader.addProblem( new CSSException( "font face rules not supported - ignored" ) ); |
| } |
| |
| public void endFontFace() throws CSSException { |
| log( "end FontFace" ); |
| } |
| |
| public StyleRule[] getStyleRules() { |
| StyleRule[] result = new StyleRule[ rules.size() ]; |
| rules.toArray( result ); |
| return result; |
| } |
| |
| private void log( final String message ) { |
| // System.out.println( message ); |
| } |
| |
| private static String toString( final SelectorList patterns ) { |
| StringBuffer buffer = new StringBuffer(); |
| buffer.append( "[" ); |
| int length = patterns.getLength(); |
| for( int i = 0; i < length; i++ ) { |
| buffer.append( " " ); |
| Selector selector = patterns.item( i ); |
| buffer.append( selector.toString() ); |
| } |
| buffer.append( " ]" ); |
| return buffer.toString(); |
| } |
| |
| private static String toString( final LexicalUnit value ) { |
| StringBuffer buffer = new StringBuffer(); |
| short type = value.getLexicalUnitType(); |
| if( type == LexicalUnit.SAC_ATTR ) { |
| buffer.append( "ATTR " + value.getStringValue() ); |
| } else if( type == LexicalUnit.SAC_CENTIMETER |
| || type == LexicalUnit.SAC_DEGREE |
| || type == LexicalUnit.SAC_EM |
| || type == LexicalUnit.SAC_EX |
| || type == LexicalUnit.SAC_GRADIAN |
| || type == LexicalUnit.SAC_HERTZ |
| || type == LexicalUnit.SAC_INCH |
| || type == LexicalUnit.SAC_KILOHERTZ |
| || type == LexicalUnit.SAC_MILLIMETER |
| || type == LexicalUnit.SAC_MILLISECOND |
| || type == LexicalUnit.SAC_PERCENTAGE |
| || type == LexicalUnit.SAC_PICA |
| || type == LexicalUnit.SAC_POINT |
| || type == LexicalUnit.SAC_PIXEL |
| || type == LexicalUnit.SAC_RADIAN |
| || type == LexicalUnit.SAC_SECOND |
| || type == LexicalUnit.SAC_DIMENSION ) |
| { |
| buffer.append( "DIM " |
| + value.getFloatValue() |
| + value.getDimensionUnitText() ); |
| } else if( type == LexicalUnit.SAC_RGBCOLOR ) { |
| LexicalUnit parameters = value.getParameters(); |
| buffer.append( "RGBCOLOR " + toString( parameters ) ); |
| } else if( type == LexicalUnit.SAC_STRING_VALUE ) { |
| buffer.append( "STRING " + value.getStringValue() ); |
| } else if( type == LexicalUnit.SAC_IDENT ) { |
| buffer.append( "IDENT " + value.getStringValue() ); |
| } else if( type == LexicalUnit.SAC_PIXEL ) { |
| buffer.append( "PIXEL " + value.getFloatValue() ); |
| } else if( type == LexicalUnit.SAC_INTEGER ) { |
| buffer.append( "INT " + value.getIntegerValue() ); |
| } else if( type == LexicalUnit.SAC_OPERATOR_COMMA ) { |
| buffer.append( "COMMA" ); |
| } else if( type == LexicalUnit.SAC_ATTR ) { |
| buffer.append( "ATTR " + value.getStringValue() ); |
| } else if( type == LexicalUnit.SAC_FUNCTION ) { |
| buffer.append( "UNKNOWN FUNCTION " + value.getFunctionName() ); |
| } else if( type == LexicalUnit.SAC_DIMENSION ) { |
| buffer.append( "UNKNOWN DIMENSION " + value ); |
| } else { |
| buffer.append( "unsupported unit " + value.getLexicalUnitType() ); |
| } |
| LexicalUnit next = value.getNextLexicalUnit(); |
| if( next != null ) { |
| buffer.append( ", " ); |
| buffer.append( toString( next ) ); |
| } |
| return buffer.toString(); |
| } |
| } |