com.github.mathiewz.slick.svg.inkscape.Util Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of modernized-slick Show documentation
The main purpose of this libraryis to modernize and maintain the slick2D library.
The newest version!
package com.github.mathiewz.slick.svg.inkscape;

import java.util.StringTokenizer;

import org.w3c.dom.Element;

import com.github.mathiewz.slick.geom.Transform;
import com.github.mathiewz.slick.svg.NonGeometricData;
import com.github.mathiewz.slick.svg.ParsingException;

/**
 * A set of utility for processing the SVG documents produced by Inkscape
 *
 * @author kevin
 */
public class Util {
    /** The namespace for inkscape */
    public static final String INKSCAPE = "http://www.inkscape.org/namespaces/inkscape";
    /** The namespace for sodipodi */
    public static final String SODIPODI = "http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd";
    /** The namespace for xlink */
    public static final String XLINK = "http://www.w3.org/1999/xlink";
    
    /**
     * Get the non-geometric data information from an XML element
     *
     * @param element
     *            The element to be processed
     * @return The non-geometric data (i.e. stroke, fill, etc)
     */
    static NonGeometricData getNonGeometricData(Element element) {
        String meta = getMetaData(element);
        
        NonGeometricData data = new InkscapeNonGeometricData(meta, element);
        data.addAttribute(NonGeometricData.ID, element.getAttribute("id"));
        data.addAttribute(NonGeometricData.FILL, getStyle(element, NonGeometricData.FILL));
        data.addAttribute(NonGeometricData.STROKE, getStyle(element, NonGeometricData.STROKE));
        data.addAttribute(NonGeometricData.OPACITY, getStyle(element, NonGeometricData.OPACITY));
        data.addAttribute(NonGeometricData.STROKE_DASHARRAY, getStyle(element, NonGeometricData.STROKE_DASHARRAY));
        data.addAttribute(NonGeometricData.STROKE_DASHOFFSET, getStyle(element, NonGeometricData.STROKE_DASHOFFSET));
        data.addAttribute(NonGeometricData.STROKE_MITERLIMIT, getStyle(element, NonGeometricData.STROKE_MITERLIMIT));
        data.addAttribute(NonGeometricData.STROKE_OPACITY, getStyle(element, NonGeometricData.STROKE_OPACITY));
        data.addAttribute(NonGeometricData.STROKE_WIDTH, getStyle(element, NonGeometricData.STROKE_WIDTH));
        
        return data;
    }
    
    /**
     * Get the meta data store within an element either in the label or
     * id atributes
     *
     * @param element
     *            The element to be processed
     * @return The meta data stored
     */
    static String getMetaData(Element element) {
        String label = element.getAttributeNS(INKSCAPE, "label");
        if (label != null && !label.equals("")) {
            return label;
        }
        
        return element.getAttribute("id");
    }
    
    /**
     * Get the style attribute setting for a given style information element (i.e. fill, stroke)
     *
     * @param element
     *            The element to be processed
     * @param styleName
     *            The name of the attribute to retrieve
     * @return The style value
     */
    static String getStyle(Element element, String styleName) {
        String value = element.getAttribute(styleName);
        
        if (value != null && value.length() > 0) {
            return value;
        }
        
        String style = element.getAttribute("style");
        return extractStyle(style, styleName);
    }
    
    /**
     * Extract the style value from a Inkscape encoded string
     *
     * @param style
     *            The style string to be decoded
     * @param attribute
     *            The style attribute to retrieve
     * @return The value for the given attribute
     */
    static String extractStyle(String style, String attribute) {
        if (style == null) {
            return "";
        }
        
        StringTokenizer tokens = new StringTokenizer(style, ";");
        
        while (tokens.hasMoreTokens()) {
            String token = tokens.nextToken();
            String key = token.substring(0, token.indexOf(':'));
            if (key.equals(attribute)) {
                return token.substring(token.indexOf(':') + 1);
            }
        }
        
        return "";
    }
    
    /**
     * Get a transform defined in the XML
     *
     * @param element
     *            The element from which the transform should be read
     * @return The transform to be applied
     */
    static Transform getTransform(Element element) {
        return getTransform(element, "transform");
    }
    
    /**
     * Get a transform defined in the XML
     *
     * @param element
     *            The element from which the transform should be read
     * @param attribute
     *            The name of the attribute holding the transform
     * @return The transform to be applied
     */
    static Transform getTransform(Element element, String attribute) {
        String str = element.getAttribute(attribute);
        if (str == null) {
            return new Transform();
        }
        
        if (str.equals("")) {
            return new Transform();
        } else if (str.startsWith("translate")) {
            str = str.substring(0, str.length() - 1);
            str = str.substring("translate(".length());
            StringTokenizer tokens = new StringTokenizer(str, ", ");
            float x = Float.parseFloat(tokens.nextToken());
            float y = Float.parseFloat(tokens.nextToken());
            
            return Transform.createTranslateTransform(x, y);
        } else if (str.startsWith("matrix")) {
            float[] pose = new float[6];
            str = str.substring(0, str.length() - 1);
            str = str.substring("matrix(".length());
            StringTokenizer tokens = new StringTokenizer(str, ", ");
            float[] tr = new float[6];
            for (int j = 0; j < tr.length; j++) {
                tr[j] = Float.parseFloat(tokens.nextToken());
            }
            
            pose[0] = tr[0];
            pose[1] = tr[2];
            pose[2] = tr[4];
            pose[3] = tr[1];
            pose[4] = tr[3];
            pose[5] = tr[5];
            
            return new Transform(pose);
        }
        
        return new Transform();
    }
    
    /**
     * Get a floating point attribute that may appear in either the default or
     * SODIPODI namespace
     *
     * @param element
     *            The element from which the attribute should be read
     * @param attr
     *            The attribute to be read
     * @return The value from the given attribute
     */
    static float getFloatAttribute(Element element, String attr) {
        String cx = element.getAttribute(attr);
        if (cx == null || cx.equals("")) {
            cx = element.getAttributeNS(SODIPODI, attr);
        }
        
        try {
            return Float.parseFloat(cx);
        } catch (NumberFormatException e) {
            throw new ParsingException(element, "Invalid value for: " + attr, e);
        }
    }
    
    /**
     * Get the attribute value as a reference to another entity
     *
     * @param value
     *            The value to treat as reference
     * @return The reference part of the attribute value
     */
    public static String getAsReference(String value) {
        if (value.length() < 2) {
            return "";
        }
        
        value = value.substring(1, value.length());
        
        return value;
    }
}