bundles/org.eclipse.rap.themeeditor/src/org/eclipse/rwt/internal/theme/css/DocumentHandlerImpl.java

/*******************************************************************************
 * 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();
  }
}