tools/generatenimbus/PainterGenerator.java

/*
 * Copyright (c) 2002, 2007, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */
package build.tools.generatenimbus;

import java.awt.geom.Point2D;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;


/**
 * PainterGenerator - Class for generating Painter class java source from a Canvas
 *
 * Following in the general theory that is used to generate a Painter file.
 *
 * Each Painter file represents a Region. So there is one painter file per region. In
 * skin.laf we support Icon subregions, which are really just hacked versions of the
 * parent region.
 *
 * In order to generate the most compact and efficient bytecode possible for the
 * Painters, we actually perform the generation sequence in two steps. The first
 * step is the analysis phase, where we walk through the SynthModel for the region
 * and discover commonality among the different states in the region. For example,
 * do they have common paths? Do they have common colors? Gradients? Is the painting
 * code for the different states identical other than for colors?
 *
 * We gather this information up. On the second pass, we use this data to determine the
 * methods that need to be generated, and the class variables that need to be generated.
 * We try to keep the actual bytecode count as small as possible so that we may reduce
 * the overall size of the look and feel significantly.
 *
 * @author  Richard Bair
 * @author  Jasper Potts
 */
public class PainterGenerator {
    //a handful of counters, incremented whenever the associated object type is encounted.
    //These counters form the basis of the field and method suffixes.
    //These are all 1 based, because I felt like it :-)
    private int colorCounter = 1;
    private int gradientCounter = 1;
    private int radialCounter = 1;
    private int pathCounter = 1;
    private int rectCounter = 1;
    private int roundRectCounter = 1;
    private int ellipseCounter = 1;

    private int stateTypeCounter = 1;

    //during the first pass, we will construct these maps
    private Map<String, String> colors = new HashMap<String, String>();
    /**
     * Code=>method name.
     */
    private Map<String, String> methods = new HashMap<String, String>();

    //these variables hold the generated code
    /**
     * The source code in this variable will be used to define the various state types
     */
    private StringBuilder stateTypeCode = new StringBuilder();
    /**
     * The source code in this variable will be used to define the switch statement for painting
     */
    private StringBuilder switchCode = new StringBuilder();
    /**
     * The source code in this variable will be used to define the methods for painting each state
     */
    private StringBuilder paintingCode = new StringBuilder();
    /**
     * The source code in this variable will be used to add getExtendedCacheKeys
     * implementation if needed.
     */
    private StringBuilder getExtendedCacheKeysCode = new StringBuilder();
    /**
     * The source code in this variable will be used to define the methods for decoding gradients
     * and shapes.
     */
    private StringBuilder gradientsCode = new StringBuilder();
    private StringBuilder colorCode = new StringBuilder();
    private StringBuilder shapesCode = new StringBuilder();
    /**
     * Map of component colors keyed by state constant name
     */
    private Map<String, List<ComponentColor>> componentColorsMap =
            new LinkedHashMap<String, List<ComponentColor>>();
    /**
     * For the current state the list of all component colors used by this
     * painter, the index in this list is also the index in the runtime array
     * of defaults and keys.
     */
    private List<ComponentColor> componentColors = null;

    PainterGenerator(UIRegion r) {
        generate(r);
    }

    private void generate(UIRegion r) {
        for (UIState state : r.getBackgroundStates()) {
            Canvas canvas = state.getCanvas();
            String type = (r instanceof UIIconRegion ? r.getKey() : "Background");
            generate(state, canvas, type);
        }
        for (UIState state : r.getForegroundStates()) {
            Canvas canvas = state.getCanvas();
            generate(state, canvas, "Foreground");
        }
        for (UIState state : r.getBorderStates()) {
            Canvas canvas = state.getCanvas();
            generate(state, canvas, "Border");
        }
        //now check for any uiIconRegions, since these are collapsed together.
        for (UIRegion sub : r.getSubRegions()) {
            if (sub instanceof UIIconRegion) {
                generate(sub);
            }
        }
        //generate all the code for component colors
        if (!componentColorsMap.isEmpty()) {
            getExtendedCacheKeysCode
                    .append("    protected Object[] getExtendedCacheKeys(JComponent c) {\n")
                    .append("        Object[] extendedCacheKeys = null;\n")
                    .append("        switch(state) {\n");
            for (Map.Entry<String, List<ComponentColor>> entry : componentColorsMap.entrySet()) {
                getExtendedCacheKeysCode
                    .append("            case ")
                    .append(entry.getKey()).append(":\n")
                    .append("                extendedCacheKeys = new Object[] {\n");
                for (int i=0; i<entry.getValue().size(); i++) {
                    ComponentColor cc = entry.getValue().get(i);
                    cc.write(getExtendedCacheKeysCode);
                    if (i + 1 < entry.getValue().size()) {
                        getExtendedCacheKeysCode.append("),\n");
                    } else {
                        getExtendedCacheKeysCode.append(")");
                    }
                }
                getExtendedCacheKeysCode.append("};\n")
                    .append("                break;\n");
            }
            getExtendedCacheKeysCode
                    .append("        }\n")
                    .append("        return extendedCacheKeys;\n")
                    .append("    }");
        }
    }

    //type is background, foreground, border, upArrowIcon, etc.
    private void generate(UIState state, Canvas canvas, String type) {
        String states = state.getStateKeys();
        String stateType = Utils.statesToConstantName(type + "_" + states);
        String paintMethodName = "paint" + type + Utils.statesToClassName(states);
        //create new array for component colors for this state
        componentColors = new ArrayList<ComponentColor>();

        stateTypeCode.append("    static final int ").append(stateType).append(" = ").append(stateTypeCounter++).append(";\n");

        if (canvas.isBlank()) {
            return;
        }

        switchCode.append("            case ").append(stateType).append(": ").append(paintMethodName).append("(g); break;\n");
        paintingCode.append("    private void ").append(paintMethodName).append("(Graphics2D g) {\n");

        //start by setting up common info needed to encode the control points
        Insets in = canvas.getStretchingInsets();
        float a = in.left;
        float b = canvas.getSize().width - in.right;
        float c = in.top;
        float d = canvas.getSize().height - in.bottom;
        float width = canvas.getSize().width;
        float height = canvas.getSize().height;
        float cw = b - a;
        float ch = d - c;

        Layer[] layers = canvas.getLayers().toArray(new Layer[0]);
        for (int index=layers.length-1; index >= 0; index--) {
            Layer layer = layers[index];

            //shapes must be painted in reverse order
            List<Shape> shapes = layer.getShapes();
            for (int i=shapes.size()-1; i>=0; i--) {
                Shape shape = shapes.get(i);
                Paint paint = shape.getPaint();

                /*
                    We attempt to write the minimal number of bytecodes as possible when
                    generating code. Due to the inherit complexities in determining what
                    is extraneous, we use the following system:

                    We first generate the code for the shape. Then, we check to see if
                    this shape has already been generated. If so, then we defer to an
                    existing method. If not, then we will create a new methods, stick
                    the code in it, and refer to that method.
                */

                String shapeMethodName = null; // will contain the name of the method which creates the shape
                String shapeVariable = null; // will be one of rect, roundRect, ellipse, or path.
                String shapeMethodBody = null;

                if (shape instanceof Rectangle) {
                    Rectangle rshape = (Rectangle) shape;
                    float x1 = encode((float)rshape.getX1(), a, b, width);
                    float y1 = encode((float)rshape.getY1(), c, d, height);
                    float x2 = encode((float)rshape.getX2(), a, b, width);
                    float y2 = encode((float)rshape.getY2(), c, d, height);
                    if (rshape.isRounded()) {
                        //it is a rounded rectangle
                        float rounding = (float)rshape.getRounding();

                        shapeMethodBody =
                                "        roundRect.setRoundRect(" +
                                writeDecodeX(x1) + ", //x\n" +
                                "                               " + writeDecodeY(y1) + ", //y\n" +
                                "                               " + writeDecodeX(x2) + " - " + writeDecodeX(x1) + ", //width\n" +
                                "                               " + writeDecodeY(y2) + " - " + writeDecodeY(y1) + ", //height\n" +
                                "                               " + rounding + "f, " + rounding + "f); //rounding";
                        shapeVariable = "roundRect";
                    } else {
                        shapeMethodBody =
                                "            rect.setRect(" +
                                writeDecodeX(x1) + ", //x\n" +
                                "                         " + writeDecodeY(y1) + ", //y\n" +
                                "                         " + writeDecodeX(x2) + " - " + writeDecodeX(x1) + ", //width\n" +
                                "                         " + writeDecodeY(y2) + " - " + writeDecodeY(y1) + "); //height";
                        shapeVariable = "rect";
                    }
                } else if (shape instanceof Ellipse) {
                    Ellipse eshape = (Ellipse) shape;
                    float x1 = encode((float)eshape.getX1(), a, b, width);
                    float y1 = encode((float)eshape.getY1(), c, d, height);
                    float x2 = encode((float)eshape.getX2(), a, b, width);
                    float y2 = encode((float)eshape.getY2(), c, d, height);
                    shapeMethodBody =
                            "        ellipse.setFrame(" +
                            writeDecodeX(x1) + ", //x\n" +
                            "                         " + writeDecodeY(y1) + ", //y\n" +
                            "                         " + writeDecodeX(x2) + " - " + writeDecodeX(x1) + ", //width\n" +
                            "                         " + writeDecodeY(y2) + " - " + writeDecodeY(y1) + "); //height";
                    shapeVariable = "ellipse";
                } else if (shape instanceof Path) {
                    Path pshape = (Path) shape;
                    List<Point> controlPoints = pshape.getControlPoints();
                    Point first, last;
                    first = last = controlPoints.get(0);
                    StringBuilder buffer = new StringBuilder();
                    buffer.append("        path.reset();\n");
                    buffer.append("        path.moveTo(" + writeDecodeX(encode((float)first.getX(), a, b, width)) + ", " + writeDecodeY(encode((float)first.getY(), c, d, height)) + ");\n");
                    for (int j=1; j<controlPoints.size(); j++) {
                        Point cp = controlPoints.get(j);
                        if (last.isP2Sharp() && cp.isP1Sharp()) {
                            float x = encode((float)cp.getX(), a, b, width);
                            float y = encode((float)cp.getY(), c, d, height);
                            buffer.append("        path.lineTo(" + writeDecodeX(x) + ", " + writeDecodeY(y) + ");\n");
                        } else {
                            float x1 = encode((float)last.getX(), a, b, width);
                            float y1 = encode((float)last.getY(), c, d, height);
                            float x2 = encode((float)cp.getX(), a, b, width);
                            float y2 = encode((float)cp.getY(), c, d, height);
                            buffer.append(
                                    "        path.curveTo(" + writeDecodeBezierX(x1, last.getX(), last.getCp2X()) + ", "
                                                            + writeDecodeBezierY(y1, last.getY(), last.getCp2Y()) + ", "
                                                            + writeDecodeBezierX(x2, cp.getX(), cp.getCp1X()) + ", "
                                                            + writeDecodeBezierY(y2, cp.getY(), cp.getCp1Y()) + ", "
                                                            + writeDecodeX(x2) + ", " + writeDecodeY(y2) + ");\n");
                        }
                        last = cp;
                    }
                    if (last.isP2Sharp() && first.isP1Sharp()) {
                        float x = encode((float)first.getX(), a, b, width);
                        float y = encode((float)first.getY(), c, d, height);
                        buffer.append("        path.lineTo(" + writeDecodeX(x) + ", " + writeDecodeY(y) + ");\n");
                    } else {
                        float x1 = encode((float)last.getX(), a, b, width);
                        float y1 = encode((float)last.getY(), c, d, height);
                        float x2 = encode((float)first.getX(), a, b, width);
                        float y2 = encode((float)first.getY(), c, d, height);
                        buffer.append(
                                "        path.curveTo(" + writeDecodeBezierX(x1, last.getX(), last.getCp2X()) + ", "
                                                        + writeDecodeBezierY(y1, last.getY(), last.getCp2Y()) + ", "
                                                        + writeDecodeBezierX(x2, first.getX(), first.getCp1X()) + ", "
                                                        + writeDecodeBezierY(y2, first.getY(), first.getCp1Y()) + ", "
                                                        + writeDecodeX(x2) + ", " + writeDecodeY(y2) + ");\n");
                    }
                    buffer.append("        path.closePath();");
                    shapeMethodBody = buffer.toString();
                    shapeVariable = "path";
                } else {
                    throw new RuntimeException("Cannot happen unless a new Shape has been defined");
                }

                //now that we have the shape defined in shapeMethodBody, and a shapeVariable name,
                //look to see if such a body has been previously defined.
                shapeMethodName = methods.get(shapeMethodBody);
                String returnType = null;
                if (shapeMethodName == null) {
                    if ("rect".equals(shapeVariable)) {
                        shapeMethodName = "decodeRect" + rectCounter++;
                        returnType = "Rectangle2D";
                    } else if ("roundRect".equals(shapeVariable)) {
                        shapeMethodName = "decodeRoundRect" + roundRectCounter++;
                        returnType = "RoundRectangle2D";
                    } else if ("ellipse".equals(shapeVariable)) {
                        shapeMethodName = "decodeEllipse" + ellipseCounter++;
                        returnType = "Ellipse2D";
                    } else {
                        shapeMethodName = "decodePath" + pathCounter++;
                        returnType = "Path2D";
                    }
                    methods.put(shapeMethodBody, shapeMethodName);

                    //since the method wasn't previously defined, time to define it
                    shapesCode.append("    private ").append(returnType).append(" ").append(shapeMethodName).append("() {\n");
                    shapesCode.append(shapeMethodBody);
                    shapesCode.append("\n");
                    shapesCode.append("        return " + shapeVariable + ";\n");
                    shapesCode.append("    }\n\n");
                }

                //now that the method has been defined, I can go on and decode the
                //paint. After the paint is decoded, I can write the g.fill() method call,
                //using the result of the shapeMethodName. Yay!

//            if (shapeVariable != null) {
            //first, calculate the bounds of the shape being painted and store in variables
                paintingCode.append("        ").append(shapeVariable).append(" = ").append(shapeMethodName).append("();\n");

                if (paint instanceof Matte) {
                    String colorVariable = encodeMatte((Matte)paint);
                    paintingCode.append("        g.setPaint(").append(colorVariable).append(");\n");
                } else if (paint instanceof Gradient) {
                    String gradientMethodName = encodeGradient(shape, (Gradient)paint);
                    paintingCode.append("        g.setPaint(").append(gradientMethodName).append("(").append(shapeVariable).append("));\n");
                } else if (paint instanceof RadialGradient) {
                    String radialMethodName = encodeRadial(shape, (RadialGradient)paint);
                    paintingCode.append("        g.setPaint(").append(radialMethodName).append("(").append(shapeVariable).append("));\n");
                }
                paintingCode.append("        g.fill(").append(shapeVariable).append(");\n");
            }
        }

        paintingCode.append("\n    }\n\n");

        //collect component colors
        if (!componentColors.isEmpty()) {
            componentColorsMap.put(stateType, componentColors);
            componentColors = null;
        }
    }

    private float encode(float x, float a, float b, float w) {
        float r = 0;
        if (x < a) {
            r = (x / a);
        } else if (x > b) {
            r = 2 + ((x - b) / (w - b));
        } else if (x == a && x == b) {
            return 1.5f;
        } else {
            r = 1 + ((x - a) / (b - a));
        }

        if (Float.isNaN(r)) {
            System.err.println("[Error] Encountered NaN: encode(" + x + ", " + a + ", " + b + ", " + w + ")");
            return 0;
        } else if (Float.isInfinite(r)) {
            System.err.println("[Error] Encountered Infinity: encode(" + x + ", " + a + ", " + b + ", " + w + ")");
            return 0;
        } else if (r < 0) {
            System.err.println("[Error] encoded value was less than 0: encode(" + x + ", " + a + ", " + b + ", " + w + ")");
            return 0;
        } else if (r > 3) {
            System.err.println("[Error] encoded value was greater than 3: encode(" + x + ", " + a + ", " + b + ", " + w + ")");
            return 3;
        } else {
            return r;
        }
    }

    private String writeDecodeX(float encodedX) {
        return "decodeX(" + encodedX + "f)";
    }

    private String writeDecodeY(float encodedY) {
        return "decodeY(" + encodedY + "f)";
    }

    /**
     *
     * @param ex encoded x value
     * @param x unencoded x value
     * @param cpx unencoded cpx value
     * @return
     */
    private static String writeDecodeBezierX(double ex, double x, double cpx) {
        return "decodeAnchorX(" + ex + "f, " + (cpx - x) + "f)";
    }

    /**
     *
     * @param ey encoded y value
     * @param y unencoded y value
     * @param cpy unencoded cpy value
     * @return
     */
    private static String writeDecodeBezierY(double ey, double y, double cpy) {
        return "decodeAnchorY(" + ey + "f, " + (cpy - y) + "f)";
    }

    private String encodeMatte(Matte m) {
        String declaration = m.getDeclaration();
        String variableName = colors.get(declaration);
        if (variableName == null) {
            variableName = "color" + colorCounter++;
            colors.put(declaration, variableName);
            colorCode.append(String.format("    private Color %s = %s;\n",
                                           variableName, declaration));
        }
        // handle component colors
        if (m.getComponentPropertyName() != null) {
            ComponentColor cc = m.createComponentColor(variableName);
            int index = componentColors.indexOf(cc);
            if (index == -1) {
                index = componentColors.size();
                componentColors.add(cc);
            }
            return "(Color)componentColors[" + index + "]";
        } else {
            return variableName;
        }
    }

    private String encodeGradient(Shape ps, Gradient g) {
        StringBuilder b = new StringBuilder();
        float x1 = (float)ps.getPaintX1();
        float y1 = (float)ps.getPaintY1();
        float x2 = (float)ps.getPaintX2();
        float y2 = (float)ps.getPaintY2();
        b.append("        return decodeGradient((");
        b.append(x1);
        b.append("f * w) + x, (");
        b.append(y1);
        b.append("f * h) + y, (");
        b.append(x2);
        b.append("f * w) + x, (");
        b.append(y2);
        b.append("f * h) + y,\n");
        encodeGradientColorsAndFractions(g,b);
        b.append(");");

        String methodBody = b.toString();
        String methodName = methods.get(methodBody);
        if (methodName == null) {
            methodName = "decodeGradient" + gradientCounter++;
            gradientsCode.append("    private Paint ").append(methodName).append("(Shape s) {\n");
            gradientsCode.append("        Rectangle2D bounds = s.getBounds2D();\n");
            gradientsCode.append("        float x = (float)bounds.getX();\n");
            gradientsCode.append("        float y = (float)bounds.getY();\n");
            gradientsCode.append("        float w = (float)bounds.getWidth();\n");
            gradientsCode.append("        float h = (float)bounds.getHeight();\n");
            gradientsCode.append(methodBody);
            gradientsCode.append("\n    }\n\n");
            methods.put(methodBody, methodName);
        }
        return methodName;
    }

    /**
     * Takes a abstract gradient and creates the code for the fractions float
     * array and the colors array that can be used in the constructors of linear
     * and radial gradients.
     *
     * @param g The abstract gradient to get stops from
     * @param b Append code string of the form "new float[]{...},
     *          new Color[]{...}" to this StringBuilder
     */
    private void encodeGradientColorsAndFractions(AbstractGradient g,
                                                    StringBuilder b) {
        List<GradientStop> stops = g.getStops();
        // there are stops.size() number of main stops. Between each is a
        // fractional stop. Thus, there are: stops.size() + stops.size() - 1
        // number of fractions and colors.
        float[] fractions = new float[stops.size() + stops.size() - 1];
        String[] colors = new String[fractions.length];
        //for each stop, create the stop and it's associated fraction
        int index = 0; // the index into fractions and colors
        for (int i = 0; i < stops.size(); i++) {
            GradientStop s = stops.get(i);
            //copy over the stop's data
            colors[index] = encodeMatte(s.getColor());
            fractions[index] = s.getPosition();

            //If this isn't the last stop, then add in the fraction
            if (index < fractions.length - 1) {
                float f1 = s.getPosition();
                float f2 = stops.get(i + 1).getPosition();
                index++;
                fractions[index] = f1 + (f2 - f1) * s.getMidpoint();
                colors[index] = "decodeColor("+
                        colors[index - 1]+","+
                        encodeMatte(stops.get(i + 1).getColor())+",0.5f)";
            }
            index++;
        }
        // Check boundry conditions
        for (int i = 1; i < fractions.length; i++) {
            //to avoid an error with LinearGradientPaint where two fractions
            //are identical, bump up the fraction value by a miniscule amount
            //if it is identical to the previous one
            //NOTE: The <= is critical because the previous value may already
            //have been bumped up
            if (fractions[i] <= fractions[i - 1]) {
                fractions[i] = fractions[i - 1] + .000001f;
            }
        }
        //another boundary condition where multiple stops are all at the end. The
        //previous loop bumped all but one of these past 1.0, which is bad.
        //so remove any fractions (and their colors!) that are beyond 1.0
        int outOfBoundsIndex = -1;
        for (int i = 0; i < fractions.length; i++) {
            if (fractions[i] > 1) {
                outOfBoundsIndex = i;
                break;
            }
        }
        if (outOfBoundsIndex >= 0) {
            float[] f = fractions;
            String[] c = colors;
            fractions = new float[outOfBoundsIndex];
            colors = new String[outOfBoundsIndex];
            System.arraycopy(f, 0, fractions, 0, outOfBoundsIndex);
            System.arraycopy(c, 0, colors, 0, outOfBoundsIndex);
        }
        // build string
        b.append("                new float[] { ");
        for (int i = 0; i < fractions.length; i++) {
            if (i>0)b.append(',');
            b.append(fractions[i]);
            b.append('f');
        }
        b.append(" },\n                new Color[] { ");
        for (int i = 0; i < colors.length; i++) {
            if (i>0) b.append(",\n                            ");
            b.append(colors[i]);
        }
        b.append("}");
    }

    private String encodeRadial(Shape ps, RadialGradient g) {
        float centerX1 = (float)ps.getPaintX1();
        float centerY1 = (float)ps.getPaintY1();
        float x2 = (float)ps.getPaintX2();
        float y2 = (float)ps.getPaintY2();
        float radius = (float)Point2D.distance(centerX1, centerY1, x2, y2);
        StringBuilder b = new StringBuilder();

        b.append("        return decodeRadialGradient((");
        b.append(centerX1);
        b.append("f * w) + x, (");
        b.append(centerY1);
        b.append("f * h) + y, ");
        b.append(radius);
        b.append("f,\n");
        encodeGradientColorsAndFractions(g,b);
        b.append(");");

        String methodBody = b.toString();
        String methodName = methods.get(methodBody);
        if (methodName == null) {
            methodName = "decodeRadial" + radialCounter++;
            gradientsCode.append("    private Paint ").append(methodName).append("(Shape s) {\n");
            gradientsCode.append("        Rectangle2D bounds = s.getBounds2D();\n");
            gradientsCode.append("        float x = (float)bounds.getX();\n");
            gradientsCode.append("        float y = (float)bounds.getY();\n");
            gradientsCode.append("        float w = (float)bounds.getWidth();\n");
            gradientsCode.append("        float h = (float)bounds.getHeight();\n");
            gradientsCode.append(methodBody);
            gradientsCode.append("\n    }\n\n");
            methods.put(methodBody, methodName);
        }
        return methodName;
    }

    //note that this method is not thread-safe. In fact, none of this class is.
    public static void writePainter(UIRegion r, String painterName) {
        //Need only write out the stuff for this region, don't need to worry about subregions
        //since this method will be called for each of those (and they go in their own file, anyway).
        //The only subregion that we compound into this is the one for icons.
        PainterGenerator gen = new PainterGenerator(r);
        System.out.println("Generating source file: " + painterName + ".java");

        Map<String, String> variables = Generator.getVariables();
        variables.put("PAINTER_NAME", painterName);
        variables.put("STATIC_DECL", gen.stateTypeCode.toString());
        variables.put("COLORS_DECL", gen.colorCode.toString());
        variables.put("DO_PAINT_SWITCH_BODY", gen.switchCode.toString());
        variables.put("PAINTING_DECL", gen.paintingCode.toString());
        variables.put("GET_EXTENDED_CACHE_KEYS", gen.getExtendedCacheKeysCode.toString());
        variables.put("SHAPES_DECL", gen.shapesCode.toString());
        variables.put("GRADIENTS_DECL", gen.gradientsCode.toString());

        Generator.writeSrcFile("PainterImpl", variables, painterName);
    }
}