Hi!
I found that the css.engine.value.RectManager (Id: RectManager.java,v 1.1 of batik 1.5beta4) doesn't compute the four length values of the rectangle to pixels. Since the conversion the LengthManager does is very useful, I added this feature to the RectManager.

If this piece of code turns out to be useful to batik, please feel free to use it.

Nicolas.
/*****************************************************************************
 * Copyright (C) The Apache Software Foundation. All rights reserved.        *
 * ------------------------------------------------------------------------- *
 * This software is published under the terms of the Apache Software License *
 * version 1.1, a copy of which has been included with this distribution in  *
 * the LICENSE file.                                                         *
 *****************************************************************************/

package org.apache.batik.css.engine.value;

import org.apache.batik.util.CSSConstants;

import org.apache.batik.css.engine.CSSEngine;
import org.apache.batik.css.engine.CSSStylableElement;
import org.apache.batik.css.engine.StyleMap;

import org.w3c.css.sac.LexicalUnit;

import org.w3c.dom.DOMException;
import org.w3c.dom.css.CSSPrimitiveValue;

/**
 * This class provides a manager for the property with support for
 * rect values.
 *
 * <small>Changed the class to resolve length values of the rectangle
 * using the {@link
 * org.apache.batik.css.engine.value.LengthManager}. <em><a
 * href="mailto:[EMAIL PROTECTED]";>Nicolas
 * Hueppelshaeuser</a></small>
 *
 * @author <a href="mailto:[EMAIL PROTECTED]";>Stephane Hillion</a>
 * @version $Id: RectManager.java,v 1.1 2002/03/18 10:28:22 hillion Exp $
 */
public abstract class RectManager extends LengthManager {
    
    /**
     * Implements {@link ValueManager#createValue(LexicalUnit,CSSEngine)}.
     */
    public Value createValue(LexicalUnit lu, CSSEngine engine)
        throws DOMException {
        switch (lu.getLexicalUnitType()) {
        case LexicalUnit.SAC_FUNCTION:
            if (!lu.getFunctionName().equalsIgnoreCase("rect")) {
                break;
            }
        case LexicalUnit.SAC_RECT_FUNCTION:
            lu = lu.getParameters();
            Value top = createRectComponent(lu);
            lu = lu.getNextLexicalUnit();
            if (lu == null ||
                lu.getLexicalUnitType() != LexicalUnit.SAC_OPERATOR_COMMA) {
                throw createMalformedRectDOMException();
            }
            lu = lu.getNextLexicalUnit();
            Value right = createRectComponent(lu);
            lu = lu.getNextLexicalUnit();
            if (lu == null ||
                lu.getLexicalUnitType() != LexicalUnit.SAC_OPERATOR_COMMA) {
                throw createMalformedRectDOMException();
            }
            lu = lu.getNextLexicalUnit();
            Value bottom = createRectComponent(lu);
            lu = lu.getNextLexicalUnit();
            if (lu == null ||
                lu.getLexicalUnitType() != LexicalUnit.SAC_OPERATOR_COMMA) {
                throw createMalformedRectDOMException();
            }
            lu = lu.getNextLexicalUnit();
            Value left = createRectComponent(lu);
            return new RectValue(top, right, bottom, left);
        }
        throw createMalformedRectDOMException();
    }

    private Value createRectComponent(LexicalUnit lu) throws DOMException {
        switch (lu.getLexicalUnitType()) {
        case LexicalUnit.SAC_IDENT:
            if (lu.getStringValue().equalsIgnoreCase
                (CSSConstants.CSS_AUTO_VALUE)) {
                return ValueConstants.AUTO_VALUE;
            }
            break;
        case LexicalUnit.SAC_EM:
            return new FloatValue(CSSPrimitiveValue.CSS_EMS,
                                  lu.getFloatValue());
        case LexicalUnit.SAC_EX:
            return new FloatValue(CSSPrimitiveValue.CSS_EXS,
                                  lu.getFloatValue());
        case LexicalUnit.SAC_PIXEL:
            return new FloatValue(CSSPrimitiveValue.CSS_PX,
                                  lu.getFloatValue());
        case LexicalUnit.SAC_CENTIMETER:
            return new FloatValue(CSSPrimitiveValue.CSS_CM,
                                  lu.getFloatValue());
        case LexicalUnit.SAC_MILLIMETER:
            return new FloatValue(CSSPrimitiveValue.CSS_MM,
                                  lu.getFloatValue());
        case LexicalUnit.SAC_INCH:
            return new FloatValue(CSSPrimitiveValue.CSS_IN,
                                  lu.getFloatValue());
        case LexicalUnit.SAC_POINT:
            return new FloatValue(CSSPrimitiveValue.CSS_PT,
                                  lu.getFloatValue());
        case LexicalUnit.SAC_PICA:
            return new FloatValue(CSSPrimitiveValue.CSS_PC,
                                  lu.getFloatValue());
        case LexicalUnit.SAC_INTEGER:
            return new FloatValue(CSSPrimitiveValue.CSS_NUMBER,
                                  lu.getIntegerValue());
        case LexicalUnit.SAC_REAL:
            return new FloatValue(CSSPrimitiveValue.CSS_NUMBER,
                                  lu.getFloatValue());
        case LexicalUnit.SAC_PERCENTAGE:
            return new FloatValue(CSSPrimitiveValue.CSS_PERCENTAGE,
                                  lu.getFloatValue());
        }
        throw createMalformedRectDOMException();
    }

    private DOMException createMalformedRectDOMException() {
        Object[] p = new Object[] { getPropertyName() };
        String s = Messages.formatMessage("malformed.rect", p);
        return new DOMException(DOMException.SYNTAX_ERR, s);
    }

    
    /**
     * Implements {@link
     * 
ValueManager#computeValue(CSSStylableElement,String,CSSEngine,int,StyleMap,Value)}.
     */
    public Value computeValue( CSSStylableElement elt,
                               String pseudo,
                               CSSEngine engine,
                               int idx,
                               StyleMap sm,
                               Value value )
    {
        if ( !(value instanceof RectValue) ) {
            return value;
        }

        Value right = ((RectValue) value).getRight();
        Value left = ((RectValue) value).getLeft();
        Value top = ((RectValue) value).getTop();
        Value bottom = ((RectValue) value).getBottom();

        Value computedRight = super.computeValue( elt, pseudo, engine, idx, sm,
                                                  right );
        Value computedLeft = super.computeValue( elt, pseudo, engine, idx, sm,
                                                 left );
        Value computedTop = super.computeValue( elt, pseudo, engine, idx, sm,
                                                top );
        Value computedBottom = super.computeValue( elt, pseudo, engine, idx, 
                                                   sm, bottom );

        return new RectValue( computedTop, computedRight, 
                              computedBottom, computedLeft );
    }

}

---------------------------------------------------------------------
To unsubscribe, e-mail: [EMAIL PROTECTED]
For additional commands, e-mail: [EMAIL PROTECTED]

Reply via email to