// XAAL toolkit
// Copyright (C) 2009 Ville Karavirta <vkaravir(a)cs.hut.fi>
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program 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 for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
package xaal.adapters;

import java.awt.Color;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.Writer;
import java.text.CharacterIterator;
import java.text.StringCharacterIterator;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.List;

import xaal.objects.Animation;
import xaal.objects.Defs;
import xaal.objects.Initial;
import xaal.objects.Xaal;
import xaal.objects.animation.AnimationOperation;
import xaal.objects.animation.CreateOperation;
import xaal.objects.animation.DeleteOperation;
import xaal.objects.animation.InsertOperation;
import xaal.objects.animation.ParOperation;
import xaal.objects.animation.RemoveOperation;
import xaal.objects.animation.SearchOperation;
import xaal.objects.animation.SeqOperation;
import xaal.objects.animation.StructureOperation;
import xaal.objects.animation.SwapIdOperation;
import xaal.objects.animation.SwapOperation;
import xaal.objects.animation.graphical.ChangePropertyOperation;
import xaal.objects.animation.graphical.ChangeStyleOperation;
import xaal.objects.animation.graphical.HideOperation;
import xaal.objects.animation.graphical.MoveOperation;
import xaal.objects.animation.graphical.ShowOperation;
import xaal.objects.animation.timing.Timing;
import xaal.objects.graphical.Circle;
import xaal.objects.graphical.ColorConverter;
import xaal.objects.graphical.Coordinate;
import xaal.objects.graphical.Ellipse;
import xaal.objects.graphical.Font;
import xaal.objects.graphical.GraphicalPrimitive;
import xaal.objects.graphical.Line;
import xaal.objects.graphical.Offset;
import xaal.objects.graphical.Polygon;
import xaal.objects.graphical.Polyline;
import xaal.objects.graphical.Rectangle;
import xaal.objects.graphical.Shape;
import xaal.objects.graphical.ShapeDefinition;
import xaal.objects.graphical.Style;
import xaal.objects.graphical.Text;
import xaal.objects.interaction.FillQuestion;
import xaal.objects.interaction.QuestionContents;
import xaal.objects.interaction.QuestionInput;
import xaal.objects.interaction.ValueEntryQuestion;
import xaal.objects.metadata.Application;
import xaal.objects.metadata.Author;
import xaal.objects.metadata.Metadata;
import xaal.objects.structures.Array;
import xaal.objects.structures.DataStructure;
import xaal.objects.structures.Edge;
import xaal.objects.structures.Index;
import xaal.objects.structures.Key;
import xaal.objects.structures.Marker;
import xaal.objects.structures.Node;
import xaal.objects.structures.Structure;
import xaal.objects.structures.Tree;
import xaal.util.ReflectionHelper;
import xaal.util.XaalConstants;

/**
 * @author vkaravir
 * 
 * To change the template for this generated type comment go to
 * Window&gt;Preferences&gt;Java&gt;Code Generation&gt;Code and Comments
 */
public class XaalObjects2XaalXML implements XaalObjectsAdapter {
    private int indent;
    private PrintWriter out;

    private Xaal xaal;
    private List doneStyles;

    /**
     * 
     */
    public XaalObjects2XaalXML() {
        super();
        doneStyles = new ArrayList();
    }

    /**
     * @see xaal.adapters.XaalObjectsAdapter#adapt(xaal.objects.Xaal, java.io.OutputStream)
     */
    public void adapt(Xaal xaal, OutputStream output) {
        this.xaal = xaal;
        out = new PrintWriter(new OutputStreamWriter(output));
        adapt(xaal, out);
    }
    
    public void adapt(Xaal xaal, Writer outwriter) {
        indent = 0;
        if (!(outwriter instanceof PrintWriter)) {
            this.out = new PrintWriter(outwriter);
        } else {
            this.out = (PrintWriter) outwriter;
        }
        out.print("<" + XaalConstants.XAAL_TAG_NAME);
        out.print(" version=\"1.0\" xmlns=\"http://www.cs.hut.fi/Research/SVG/XAAL\"  xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:schemaLocation=\"http://www.cs.hut.fi/Research/SVG/XAAL xaal.xsd\">\n");
        indent++;
        Metadata md = xaal.getMetadata();
        convert(md);
        Defs defs = xaal.getDefs();
        convert(defs);
        out.print(emptyString(indent) + "<");
        out.print(XaalConstants.INITIAL_TAG_NAME + ">\n");
        indent++;
        Initial init = xaal.getInitial();
        Iterator iter;
        if (init != null) {
            iter = init.getStructures();
            while (iter.hasNext()) {
                DataStructure ds = (DataStructure) iter.next();
                ReflectionHelper.invoke(ds, this, "convert");
            }
            iter = init.getGraphicals();
            while (iter.hasNext()) {
                GraphicalPrimitive gp = (GraphicalPrimitive) iter.next();
                ReflectionHelper.invoke(gp, this, "convert");            
            }

            // iter = xaal.getAnimation().getOperations(); while (iter.hasNext()) {
            // AnimationOperation oper = (AnimationOperation) iter.next();
            // convert(oper); }
        }
        indent--;
        out.print(emptyString(indent) + "</");
        out.print(XaalConstants.INITIAL_TAG_NAME + ">\n");
        // TODO Handle XO2Xaal animation adaptation
        Animation anim = xaal.getAnimation();
        if (anim != null) {
            out.print(emptyString(indent) + "<");
            out.print(XaalConstants.ANIMATION_TAG_NAME + ">\n");
            indent++;
            iter = anim.getGraphicals();
            while (iter.hasNext()) {
                GraphicalPrimitive gp = (GraphicalPrimitive) iter.next();
                ReflectionHelper.invoke(gp, this, "convert");            
            }
            iter = anim.getOperations();
            while (iter.hasNext()) {
                AnimationOperation oper = (AnimationOperation) iter.next();
                ReflectionHelper.invoke(oper, this, "convert");
            }
            indent--;
            out.print(emptyString(indent) + "</");
            out.print(XaalConstants.ANIMATION_TAG_NAME + ">\n");
            indent--;
        }
        out.print("</" + XaalConstants.XAAL_TAG_NAME + ">\n");
        out.flush();
    }

    private void convert(Defs defs) {
        out.print(emptyString(indent) + "<");
        out.print(XaalConstants.DEFS_TAG_NAME + ">\n");
        indent++;
        Iterator<String> options = defs.getOptionNames();
        while (options.hasNext()) {
            String name = options.next();
            out.print(emptyString(indent) + "<");
            out.print(XaalConstants.OPTION_TAG_NAME);
            out.print(" name=\"" + name + "\" value=\"");
            out.print(defs.getOption(name) + "\"/>\n");
        }
        Iterator<Style> styles = defs.getStyles();
        while (styles.hasNext()) {
            appendStyle(styles.next());
        }
        Iterator<ShapeDefinition> shapes = defs.getShapeDefinitions();
        while (shapes.hasNext()) {
            appendShapeDef(shapes.next());
        }
        indent--;
        out.print(emptyString(indent) + "</");
        out.print(XaalConstants.DEFS_TAG_NAME + ">\n");
        
    }

    private void appendShapeDef(ShapeDefinition sdef) {
        out.print(emptyString(indent) + "<");
        out.print(XaalConstants.DEFINESHAPE_TAG_NAME);
        out.print(" name=\"" + sdef.getName() + "\">\n");
        indent++;
        Iterator<GraphicalPrimitive> gps = sdef.getGraphicals();
        while (gps.hasNext()) {
            ReflectionHelper.invoke(gps.next(), this, "convert");
        }
        indent--;
        out.print(emptyString(indent) + "</");
        out.print(XaalConstants.DEFINESHAPE_TAG_NAME + ">\n");

    }

    public void convert(Metadata md) {
        if (md == null)
            return;
        out.print(emptyString(indent) + "<");
        out.print(XaalConstants.METADATA_TAG_NAME + ">\n");
        indent++;
        Iterator iter = md.getAuthors();
        while (iter.hasNext())
            convert((Author) iter.next());
        iter = md.getApplications();
        while (iter.hasNext())
            convert((Application) iter.next());
        out.print(emptyString(indent) + "<");
        out.print(XaalConstants.ANIMATIONINFO_TAG_NAME + ">\n");
        indent++;
        if (md.getTitle() != null) {
            out.print(emptyString(indent) + "<");
            out.print(XaalConstants.ANIMATIONTITLE_TAG_NAME + ">");
            out.print(md.getTitle().trim());
            out.print("</" + XaalConstants.ANIMATIONTITLE_TAG_NAME + ">\n");
        }

        if (md.getSubject() != null) {
            out.print(emptyString(indent) + "<");
            out.print(XaalConstants.ANIMATIONSUBJECT_TAG_NAME + ">");
            out.print(md.getSubject().trim());
            out.print("</" + XaalConstants.ANIMATIONSUBJECT_TAG_NAME + ">\n");
        }

        if (md.getDesc() != null) {
            out.print(emptyString(indent) + "<");
            out.print(XaalConstants.ANIMATIONDESC_TAG_NAME + ">");
            out.print(md.getDesc());
            out.print(emptyString(indent) + "</");
            out.print(XaalConstants.ANIMATIONDESC_TAG_NAME + ">\n");
        }

        iter = md.getKeywords();
        while (iter.hasNext()) {
            out.print(emptyString(indent) + "<");
            out.print(XaalConstants.ANIMATIONKEYWORD_TAG_NAME + ">");
            out.print(iter.next());
            out.print(emptyString(indent) + "</");
            out.print(XaalConstants.ANIMATIONKEYWORD_TAG_NAME + ">\n");
        }
        indent--;
        out.print(emptyString(indent) + "</");
        out.print(XaalConstants.ANIMATIONINFO_TAG_NAME + ">\n");

        indent--;
        out.print(emptyString(indent) + "</");
        out.print(XaalConstants.METADATA_TAG_NAME + ">\n");

    }

    private void convert(Application application) {
        if (application == null)
            return;
        out.print(emptyString(indent) + "<");
        out.print(XaalConstants.APPLICATION_TAG_NAME + ">\n");
        indent++;
        out.print(emptyString(indent) + "<");
        out.print(XaalConstants.APPLICATION_NAME_TAG_NAME + ">");
        out.print(application.getName());
        out.print("</" + XaalConstants.APPLICATION_NAME_TAG_NAME + ">\n");

        if (application.getVersion() != null) {
            out.print(emptyString(indent) + "<");
            out.print(XaalConstants.APPLICATION_VERSION_TAG_NAME + ">");
            out.print(application.getVersion());
            out.print("</" + XaalConstants.APPLICATION_VERSION_TAG_NAME + ">\n");
        }

        if (application.getHomepage() != null) {
            out.print(emptyString(indent) + "<");
            out.print(XaalConstants.APPLICATION_HOMEPAGE_TAG_NAME + ">");
            out.print(application.getHomepage());
            out.print("</" + XaalConstants.APPLICATION_HOMEPAGE_TAG_NAME + ">\n");
        }
        indent--;
        out.print(emptyString(indent) + "</");
        out.print(XaalConstants.APPLICATION_TAG_NAME + ">\n");

    }

    public void convert(Author author) {
        if (author == null)
            return;
        out.print(emptyString(indent) + "<");
        out.print(XaalConstants.AUTHOR_TAG_NAME + ">\n");
        indent++;
        out.print(emptyString(indent) + "<");
        out.print(XaalConstants.FIRSTNAME_TAG_NAME + ">");
        if (author.getFirstName() != null) {
            out.print(escapeXmlEntities(author.getFirstName().trim()));
        }
        out.print("</" + XaalConstants.FIRSTNAME_TAG_NAME + ">\n");

        out.print(emptyString(indent) + "<");
        out.print(XaalConstants.LASTNAME_TAG_NAME + ">");
        if (author.getLastName() != null) {
            out.print(escapeXmlEntities(author.getLastName().trim()));
        }
        out.print("</" + XaalConstants.LASTNAME_TAG_NAME + ">\n");

        if (author.getAffiliation() != null) {
            out.print(emptyString(indent) + "<");
            out.print(XaalConstants.AFFILIATION_TAG_NAME + ">");
            out.print(escapeXmlEntities(author.getAffiliation()));
            out.print(emptyString(indent) + "</");
            out.print(XaalConstants.AFFILIATION_TAG_NAME + ">\n");
        }

        if (author.getEmail() != null) {
            out.print(emptyString(indent) + "<");
            out.print(XaalConstants.EMAIL_TAG_NAME + ">");
            out.print(escapeXmlEntities(author.getEmail()));
            out.print(emptyString(indent) + "</");
            out.print(XaalConstants.EMAIL_TAG_NAME + ">\n");
        }
        indent--;
        out.print(emptyString(indent) + "</");
        out.print(XaalConstants.AUTHOR_TAG_NAME + ">\n");

    }

    /**
     * @param ds
     */
    public void convert(DataStructure ds) {
        if (ds.getType() == DataStructure.GRAPH_TYPE)
            convertGraph(ds);
    }

    public void convert(Marker m) {
        out.print(emptyString(indent) + "<" + XaalConstants.MARKER_TAG_NAME);
        appendId(m);
        appendStyleAttr(m.getStyle());
        out.print(" target=\"" + m.getTarget().getId() + "\"");
        if (m.getLabel() != null)
            out.print(" label=\"" + m.getLabel() + "\"");
        out.print("/>\n");
    }
    
    /**
     * @param array
     */
    public void convert(Array array) {
        out.print(emptyString(indent) + "<" + XaalConstants.ARRAY_TAG_NAME);
        out.print(" " + XaalConstants.ORIENTATION_ATTRIBUTE_NAME);
        out.print("=\"" + array.getOrientation() + "\"");
        if (array.getSize() != -1) {
            out.print(" " + XaalConstants.SIZE_ATTRIBUTE_NAME);
            out.print("=\"" + array.getSize() + "\"");
        }
        out.print(" " + XaalConstants.INDEXED_ATTRIBUTE_NAME);
        out.print("=\"" + array.isIndexed() + "\"");
        appendId(array);
        appendStyleAttr(array.getStyle());
        out.print(">\n");
        indent += 1;
        appendNarrative(array);
        appendProperties(array);
        appendPosition(array);
        appendStyle(array.getStyle());
        appendGraphicalRepresentation(array);
        Iterator iter = array.getNodes();
        while (iter.hasNext()) {
            ReflectionHelper.invoke(iter.next(), this, "convert");
        }
        indent -= 1;
        out.print(emptyString(indent) + "</" + XaalConstants.ARRAY_TAG_NAME + ">\n");
    }

    public void convert(xaal.objects.structures.List list) {
        out.print(emptyString(indent) + "<" + XaalConstants.LIST_TAG_NAME);
        out.print(" " + XaalConstants.ORIENTATION_ATTRIBUTE_NAME);
        out.print("=\"" + list.getOrientation() + "\"");
        appendId(list);
        appendStyleAttr(list.getStyle());
        if (appendRef(list)) {
            out.print("/>\n");
            return;
        }
        out.print(">\n");
        indent += 1;
        appendNarrative(list);
        appendProperties(list);
        appendPosition(list);
        appendStyle(list.getStyle());
        appendGraphicalRepresentation(list);
        Iterator iter = list.getNodes();
        while (iter.hasNext())
            ReflectionHelper.invoke(iter.next(), this, "convert");
        iter = list.getReferences();
        while (iter.hasNext())
            ReflectionHelper.invoke(iter.next(), this, "convert");
        indent -= 1;
        out.print(emptyString(indent) + "</" + XaalConstants.LIST_TAG_NAME + ">\n");
    }

    private void convertGraph(DataStructure graph) {
        out.print(emptyString(indent) + "<" + XaalConstants.GRAPH_TAG_NAME);
        appendId(graph);
        appendStyleAttr(graph.getStyle());
        if (appendRef(graph)) {
            out.print("/>\n");
            return;
        }
        out.print(">\n");
        indent += 1;
        appendNarrative(graph);
        appendProperties(graph);
        appendPosition(graph);
        appendStyle(graph.getStyle());
        appendGraphicalRepresentation(graph);
        Iterator iter = graph.getNodes();
        while (iter.hasNext())
            ReflectionHelper.invoke(iter.next(), this, "convert");
        iter = graph.getReferences();
        while (iter.hasNext())
            ReflectionHelper.invoke(iter.next(), this, "convert");
        indent -= 1;
        out.print(emptyString(indent) + "</" + XaalConstants.GRAPH_TAG_NAME + ">\n");
    }

    public void convert(Key key) {
        out.print(emptyString(indent) + "<" + XaalConstants.KEY_TAG_NAME);
        out.print(" value=\"" + key.getValue() + "\"");
        appendId(key);
        appendStyleAttr(key.getStyle());
        out.print(">\n");
        indent += 1;
        appendNarrative(key);
        appendProperties(key);
        appendPosition(key);
        appendStyle(key.getStyle());
        appendGraphicalRepresentation(key);
        indent -= 1;
        out.print(emptyString(indent) + "</" + XaalConstants.KEY_TAG_NAME + ">\n");
    }

    public void convert(Node node) {
        out.print(emptyString(indent) + "<" + XaalConstants.NODE_TAG_NAME);
        appendNodeAttributes(node);
        appendId(node);
        appendStyleAttr(node.getStyle());
        out.print(">\n");
        indent += 1;
        appendNarrative(node);
        appendProperties(node);
        appendPosition(node);
        appendStyle(node.getStyle());
        appendGraphicalRepresentation(node);
        ReflectionHelper.invoke(node.getContent(), this, "convert");
        indent -= 1;
        out.print(emptyString(indent) + "</" + XaalConstants.NODE_TAG_NAME + ">\n");
    }

    public void convert(Index ind) {
        out.print(emptyString(indent) + "<" + XaalConstants.INDEX_TAG_NAME);
        if (ind.getIndex() != -1)
            out.print(" index=\"" + ind.getIndex() + "\"");
        appendNodeAttributes(ind);
        appendId(ind);
        appendStyleAttr(ind.getStyle());
        out.print(">\n");
        indent += 1;
        appendNarrative(ind);
        appendProperties(ind);
        appendPosition(ind);
        appendStyle(ind.getStyle());
        appendGraphicalRepresentation(ind);
        ReflectionHelper.invoke(ind.getContent(), this, "convert");
        indent -= 1;
        out.print(emptyString(indent) + "</" + XaalConstants.INDEX_TAG_NAME + ">\n");
    }

    private void appendNodeAttributes(Node n) {
        if (n.getLabel() == null)
            return;
        out.print(" " + XaalConstants.LABEL_ATTRIBUTE_NAME);
        out.print("=\"" + n.getLabel() + "\"");
    }

    public void convert(Edge ref) {
        out.print(emptyString(indent) + "<" + XaalConstants.EDGE_TAG_NAME);
        appendId(ref);
        appendStyleAttr(ref.getStyle());
        if (ref.isLabeled())
            out.print(" label=\"" + ref.getLabel() + "\"");
        out.print(" from=\"" + ref.getFrom());
        out.print("\"" + " to=\"" + ref.getTo());
        out.print("\" directed=\"" + ref.isDirected());
        out.print("\">\n");
        indent += 1;
        appendNarrative(ref);
        appendProperties(ref);
        appendStyle(ref.getStyle());
        appendGraphicalRepresentation(ref);
        indent -= 1;
        out.print(emptyString(indent) + "</" + XaalConstants.EDGE_TAG_NAME + ">\n");

    }

    public void convert(Tree tree) {
        out.print(emptyString(indent) + "<" + XaalConstants.TREE_TAG_NAME);
        appendId(tree);
        appendStyleAttr(tree.getStyle());
        if (appendRef(tree)) {
            out.print("/>\n");
            return;
        }
        out.print(" root=\"" + tree.getRoot() + "\">\n");
        indent += 1;
        appendNarrative(tree);
        appendProperties(tree);
        appendPosition(tree);
        appendStyle(tree.getStyle());
        appendGraphicalRepresentation(tree);
        Iterator iter = tree.getNodes();
        while (iter.hasNext())
            ReflectionHelper.invoke(iter.next(), this, "convert");
        iter = tree.getReferences();
        while (iter.hasNext())
            ReflectionHelper.invoke(iter.next(), this, "convert");
        indent -= 1;
        out.print(emptyString(indent) + "</" + XaalConstants.TREE_TAG_NAME + ">\n");
    }

    // Conversion of Graphical Primitives
    public void convert(GraphicalPrimitive gp) {
        if (xaal.getErrorLog() != null) {
            xaal.getErrorLog().warn(this,
                                "Unknown graphical primitive: "
                                        + gp.getClass().getName());
        } else {
            System.err.println("Unknown graphical primitive: "
            + gp.getClass().getName());
        }
    }
    
    public void convert(Shape s) {
        out.print(emptyString(indent) + "<");
        out.print(XaalConstants.SHAPE_TAG_NAME);
        out.print(" id=\"" + s.getId() + "\"");
        out.print(" uses=\"" + s.getShapeDefinition().getName() + "\">\n");
        indent++;
        appendCoordinate(s.getCoordinate(), XaalConstants.COORDINATE_TAG_NAME);
        if (s.getScale() != 1) {
            out.print(emptyString(indent) + "<");
            out.print(XaalConstants.SHAPESCALE_TAG_NAME);
            out.print(" value=\"" + s.getScale() + "\"/>\n");
        }
        appendDepth(s.getDepth());
        indent--;
        out.print(emptyString(indent) + "</");
        out.print(XaalConstants.SHAPE_TAG_NAME + ">\n");
    }
    
    public void convert(HideOperation ho) {
    	out.print(emptyString(indent) + "<");
        out.print(XaalConstants.HIDE_TAG_NAME);
        out.print(" type=\"" + ho.getType() + "\">\n");
        //out.print(" objects=\""+ho.getGraphicalPrimitives().size()+"\"");
        indent += 1;
        Iterator iter = ho.getGraphicals();
        while (iter.hasNext()) {
            GraphicalPrimitive gp = (GraphicalPrimitive) iter.next();
            if (gp != null)
                appendObjectRef(gp);
        }
        iter = ho.getStructures();
        while (iter.hasNext()) {
            Structure str = (Structure) iter.next();
            appendObjectRef(str);
        }
        indent -= 1;
        out.print(emptyString(indent) + "</");
        out.print(XaalConstants.HIDE_TAG_NAME + ">\n");
    }
    
    
    public void convert(ShowOperation so) {
        out.print(emptyString(indent) + "<");
        out.print(XaalConstants.SHOW_TAG_NAME + ">\n");
        indent += 1;
        Iterator iter = so.getGraphicals();
        while (iter.hasNext()) {
            GraphicalPrimitive gp = (GraphicalPrimitive) iter.next();
            appendObjectRef(gp);
        }
        iter = so.getStructures();
        while (iter.hasNext()) {
            Structure str = (Structure) iter.next();
            appendObjectRef(str);
        }
        indent -= 1;
        out.print(emptyString(indent) + "</");
        out.print(XaalConstants.SHOW_TAG_NAME + ">\n");
    }
    
    public void convert(MoveOperation mo) {
        out.print(emptyString(indent) + "<" + XaalConstants.MOVE_TAG_NAME);
        out.print(" type=\"" + mo.getType() + "\">\n");
        //out.print(" objects=\""+ho.getGraphicalPrimitives().size()+"\"");
        indent += 1;
        Iterator iter = mo.getGraphicals();
        while (iter.hasNext()) {
            GraphicalPrimitive gp = (GraphicalPrimitive) iter.next();
            appendObjectRef(gp, mo.getObjectData(gp));
        }
        iter = mo.getStructures();
        while (iter.hasNext()) {
            Structure str = (Structure) iter.next();
            appendObjectRef(str);
        }
        if (mo.getNewCoordinate() != null)
            appendCoordinate(mo.getNewCoordinate(), XaalConstants.COORDINATE_TAG_NAME);
        indent -= 1;
        out.print(emptyString(indent) + "</");
        out.print(XaalConstants.MOVE_TAG_NAME + ">\n");       
    }
    
    public void convert(ChangeStyleOperation cso) {
        out.print(emptyString(indent) + "<");
        out.print(XaalConstants.CHANGESTYLE_TAG_NAME );
        if (doneStyles.contains(cso.getStyle())) 
            out.print(" style-ref=\"" + cso.getStyle().getId() + "\"");
        out.print(">\n");
        indent += 1;
        Iterator iter = cso.getGraphicals();
        while (iter.hasNext()) {
            GraphicalPrimitive gp = (GraphicalPrimitive) iter.next();
            appendObjectRef(gp);
        }
        iter = cso.getStructures();
        while (iter.hasNext()) {
            Structure str = (Structure) iter.next();
            appendObjectRef(str);
        }
        appendTiming(cso);
        appendStyle(cso.getStyle());
        indent -= 1;
        out.print(emptyString(indent) + "</");
        out.print(XaalConstants.CHANGESTYLE_TAG_NAME + ">\n");
    }
    
    
    public void convert(FillQuestion fq) {
    	out.print(emptyString(indent) + "<");
    	out.print(XaalConstants.FILLQUESTION_TAG_NAME);
    	out.print(" id=\"" + fq.getId() + "\">\n");
    	indent += 1;
    	appendQuestionContents(fq.getAnswer());
    	appendQuestionContents(fq.getHint());
    	appendQuestionContents(fq.getLabel());
    	appendQuestionContents(fq.getFeedback());
    	indent -= 1;
        out.print(emptyString(indent) + "</");
        out.print(XaalConstants.FILLQUESTION_TAG_NAME + ">\n");       
    }
    
    public void convert(ValueEntryQuestion fq) {
    	out.print(emptyString(indent) + "<");
    	out.print(XaalConstants.VALUEENTRYQUESTION_TAG_NAME);
    	out.print(" id=\"" + fq.getId() + "\">\n");
    	indent += 1;
    	appendQuestionInput(fq.getAnswer());
    	appendQuestionContents(fq.getHint());
    	appendQuestionContents(fq.getLabel());
    	appendQuestionContents(fq.getFeedback());
    	indent -= 1;
        out.print(emptyString(indent) + "</");
        out.print(XaalConstants.VALUEENTRYQUESTION_TAG_NAME + ">\n");       
    }


    private void appendQuestionInput(QuestionInput input) {
    	out.print(emptyString(indent) + "<input");
    	if (input.getAnswer() != null) {
    		out.print(" answer=\"" + input.getAnswer() + "\"");
    	}
    	out.print("/>\n");
	}

	private void appendQuestionContents(QuestionContents contents) {
    	if (contents == null) {
    		return;
    	}
    	out.print(emptyString(indent) + "<contents");
    	out.print(" type=\"" + contents.getType() + "\">");
    	Iterator<Object> i = contents.getItems();
    	while (i.hasNext()) {
    		out.print(i.next());
    	}
    	out.print("</contents>\n");
	}

	private void appendObjectRef(GraphicalPrimitive gp) {
        if (gp == null) {
            return;
        }
        out.print(emptyString(indent) + "<" + XaalConstants.OBJECTREF_TAG_NAME);
        out.print(" id=\"" + gp.getId() + "\"" + "/>\n");
               
    }

	private void appendObjectRef(GraphicalPrimitive gp, Object data) {
        if (gp == null) {
            return;
        }
        out.print(emptyString(indent) + "<" + XaalConstants.OBJECTREF_TAG_NAME);
        if (data != null) {
        	out.print(" node=\"" + data + "\"");
        }
        out.print(" id=\"" + gp.getId() + "\"" + "/>\n");
               
    }

    private void appendObjectRef(Structure str) {
        out.print(emptyString(indent) + "<" + XaalConstants.OBJECTREF_TAG_NAME);
        out.print(" id=\"" + str.getId() + "\"" + "/>\n");
               
    }

    private void appendObjectRef(Coordinate c) {
        out.print(emptyString(indent) + "<" + XaalConstants.OBJECTREF_TAG_NAME);
        out.print(" id=\"" + c.getId() + "\"" + "/>\n");
               
    }

    public void convert(Text text) {
        out.print(emptyString(indent) + "<" + XaalConstants.TEXT_TAG_NAME);
        appendGraphicalPrimitiveAttributes(text);
        appendStyleAttr(text.getStyle());
        out.print(">\n");
        indent++;
        Coordinate c = text.getCoordinate();
        appendCoordinate(c, XaalConstants.COORDINATE_TAG_NAME);
        out.print(emptyString(indent));
        out.print("<alignment value=\"" + text.getAlignment());
        out.print("\"/>\n");
        out.print(emptyString(indent));
        out.print("<boxed value=\"" + text.isBoxed());
        out.print("\"/>\n");
        out.print(emptyString(indent) + "<");
        // TODO handle multiple languages
        Iterator iter = text.getLanguages();
        while (iter.hasNext()) {
            String lang = iter.next().toString();
            out.print(XaalConstants.CONTENTS_TAG_NAME + " lang=\"");
            out.print(lang + "\">");
            out.print(escapeXmlEntities(text.getContents(lang)));
            out.print("</");
            out.print(XaalConstants.CONTENTS_TAG_NAME + ">\n");
        }
        if (text.getContents() != null) { // default text
            out.print(XaalConstants.CONTENTS_TAG_NAME + ">");
            out.print(escapeXmlEntities(text.getContents()));
            out.print("</");
            out.print(XaalConstants.CONTENTS_TAG_NAME + ">\n");
        }
        appendDepth(text.getDepth());
        appendStyle(text.getStyle());
        indent--;
        out.print(emptyString(indent) + "</" + XaalConstants.TEXT_TAG_NAME + ">\n");

    }

    public void convert(Polygon p) {
        out.print(emptyString(indent) + "<" + XaalConstants.POLYGON_TAG_NAME);
        appendGraphicalPrimitiveAttributes(p);
        appendStyleAttr(p.getStyle());
        out.print(">\n");
        indent++;
        Iterator iter = p.getPoints();
        while (iter.hasNext())
            appendCoordinate((Coordinate) iter.next(),
                             XaalConstants.COORDINATE_TAG_NAME);
        appendDepth(p.getDepth());
        appendStyle(p.getStyle());
        indent--;
        out.print(emptyString(indent) + "</" + XaalConstants.POLYGON_TAG_NAME + ">\n");

    }

    public void convert(Line l) {
        out.print(emptyString(indent) + "<" + XaalConstants.LINE_TAG_NAME);
        appendGraphicalPrimitiveAttributes(l);
        appendStyleAttr(l.getStyle());
        out.print(">\n");
        indent++;
        Iterator iter = l.getPoints();
        while (iter.hasNext())
            appendCoordinate((Coordinate) iter.next(),
                             XaalConstants.COORDINATE_TAG_NAME);
        appendDepth(l.getDepth());
        appendStyle(l.getStyle());
        indent--;
        out.print(emptyString(indent) + "</");
        out.print(XaalConstants.LINE_TAG_NAME + ">\n");
    }

    public void convert(Polyline p) {
        out.print(emptyString(indent) + "<" + XaalConstants.POLYLINE_TAG_NAME);
        appendGraphicalPrimitiveAttributes(p);
        appendStyleAttr(p.getStyle());
        out.print(">\n");
        indent++;
        Iterator iter = p.getPoints();
        while (iter.hasNext())
            appendCoordinate((Coordinate) iter.next(),
                             XaalConstants.COORDINATE_TAG_NAME);
        out.print(emptyString(indent) + "<" + XaalConstants.CLOSED_TAG_NAME);
        out.print(" value=\"" + p.isClosed() + "\"/>\n");
        appendDepth(p.getDepth());
        appendStyle(p.getStyle());
        indent--;
        out.print(emptyString(indent) + "</" + XaalConstants.POLYLINE_TAG_NAME + ">\n");

    }

    public void convert(Rectangle r) {
        out.print(emptyString(indent) + "<" + XaalConstants.RECTANGLE_TAG_NAME);
        appendGraphicalPrimitiveAttributes(r);
        appendStyleAttr(r.getStyle());
        out.print(">\n");
        indent++;
        appendCoordinate(r.getStartCoordinate(),
                         XaalConstants.COORDINATE_TAG_NAME);
        appendCoordinate(r.getEndCoordinate(),
                         XaalConstants.COORDINATE_TAG_NAME);
        int[] round = r.getRound();
        if (round[0] != 0 && round[1] != 0) {
            out.print(emptyString(indent) + "<" + XaalConstants.ROUND_TAG_NAME);
            out.print(" x=\"" + round[0] + "\" y=\"");
            out.print(round[1] + "\"/>\n");
        }
        appendDepth(r.getDepth());
        appendStyle(r.getStyle());
        indent--;
        out.print(emptyString(indent) + "</" + XaalConstants.RECTANGLE_TAG_NAME + ">\n");

    }

    public void convert(Circle c) {
        out.print(emptyString(indent) + "<" + XaalConstants.CIRCLE_TAG_NAME);
        appendGraphicalPrimitiveAttributes(c);
        appendStyleAttr(c.getStyle());
        out.print(">\n");
        indent++;
        appendCoordinate(c.getCenter(), XaalConstants.CENTER_TAG_NAME);
        out.print(emptyString(indent) + "<");
        out.print(XaalConstants.RADIUS_TAG_NAME);
        out.print(" length=\"" + c.getRadius().getLength() + "\"/>\n");
        appendDepth(c.getDepth());
        appendStyle(c.getStyle());
        indent--;
        out.print(emptyString(indent) + "</" + XaalConstants.CIRCLE_TAG_NAME + ">\n");
    }

    public void convert(Ellipse e) {
        out.print(emptyString(indent) + "<" + XaalConstants.ELLIPSE_TAG_NAME);
        appendGraphicalPrimitiveAttributes(e);
        appendStyleAttr(e.getStyle());
        out.print(">\n");
        indent++;
        appendCoordinate(e.getCenter(), XaalConstants.CENTER_TAG_NAME);
        out.print(emptyString(indent) + "<");
        out.print(XaalConstants.RADIUS_TAG_NAME);
        out.print(" x=\"" + e.getRadius().getX() + " y=\"" + e.getRadius().getY() + "\"/>\n");
        appendDepth(e.getDepth());
        appendStyle(e.getStyle());
        indent--;
        out.print(emptyString(indent) + "</" + XaalConstants.ELLIPSE_TAG_NAME + ">\n");
    }

    // Code used to add indentations of certain lengths
    private static final String[] empties = new String[50];
    static {
        String s = "";
        for (int i = 0; i < 50; i++) {
            empties[i] = s;
            s += "  ";
        }
    }

    /**
     * @param length
     * @return An empty string of length twice the value of the given value.
     */
    public static final String emptyString(int length) {
        return empties[length];
    }

    /**
     * @param ds
     */
    private void appendId(Structure ds) {
        if (ds.getId() != null)
            out.print(" id=\"" + ds.getId() + "\"");
    }

    /**
     * @param ds
     */
    private void appendId(AnimationOperation ao) {
        if (ao.getId() != null)
            out.print(" id=\"" + ao.getId() + "\"");
    }

    private void appendTiming(AnimationOperation ao) {
        if (ao.getTiming() != null && (ao.getTiming().getDelay() > 0 || ao.getTiming().getDuration() > 0)) {
            out.print(emptyString(indent) + "<timing>\n");
            indent++;
            if (ao.getTiming().getDelay() > 0) {
                out.print(emptyString(indent) + "<delay ");
                appendTimingAttribute(ao.getTiming().getDelay(), ao.getTiming().getDelayType());
                out.print("/>\n");
            }
            if (ao.getTiming().getDuration() > 0) {
                out.print(emptyString(indent) + "<duration ");
                appendTimingAttribute(ao.getTiming().getDuration(), ao.getTiming().getDurationType());
                out.print("/>\n");
            }
            indent--;
            out.print(emptyString(indent) + "</timing>\n");
        }
    }
    
    private void appendTimingAttribute(int delay, String delayType) {
        if (delayType.toLowerCase().equals(Timing.FRAMES_TYPE)) {
            out.print("frames=\"" + delay + "\"");
        } else if (delayType.toLowerCase().equals(Timing.MS_TYPE)) {
            out.print("ms=\"" + delay + "\"");
        } else if (delayType.toLowerCase().equals(Timing.S_TYPE)) {
            out.print("s=\"" + delay + "\"");
        } 
    }

    private void appendGraphicalPrimitiveAttributes(GraphicalPrimitive gp) {
        out.print(" id=\"" + gp.getId() + "\"");
        out.print(" hidden=\"" + gp.isHidden() + "\"");
        out.print(" opacity=\"" + gp.getOpacity() + "\"");
    }

    /**
     * @param ds
     */
    private void appendGraphicalRepresentation(Structure ds) {
        Iterator iter = ds.getGraphicals();
        if (iter == null || !iter.hasNext()) // no graphical primitives, do
            // nothing
            return;
        out.print(emptyString(indent) + "<graphical>\n");
        indent++;
        while (iter.hasNext()) {
            ReflectionHelper.invoke(iter.next(), this, "convert");
        }
        indent--;
        out.print(emptyString(indent) + "</graphical>\n");
    }
    
    private void appendGraphicalRepresentation(StructureOperation so) {
    	Iterator iter = so.getGraphicals();
        if (iter == null || !iter.hasNext()) // no graphical primitives, do
            // nothing
            return;
        out.print(emptyString(indent) + "<graphical>\n");
        indent++;
        while (iter.hasNext()) {
            ReflectionHelper.invoke(iter.next(), this, "convert");
        }
        indent--;
        out.print(emptyString(indent) + "</graphical>\n");
    }

    /**
     * @param ds
     */
    private void appendProperties(Structure ds) {
        Enumeration enm = ds.getProperties();
        while (enm.hasMoreElements()) {
            String name = enm.nextElement().toString();
            out.print(emptyString(indent) + "<");
            out.print(XaalConstants.STRUCTUREPROPERTY_TAG_NAME + " name=\"" + name + "\" value=\"" + ds.getProperty(name) + "\"/>\n");
        }
    }

    private void appendNarrative(Structure s) {
        if (s.getNarrative() != null)
            appendNarrative(s.getNarrative());
    }

    /**
     * @param ind
     */
    private void appendPosition(Structure s) {
        if (s.getCoordinate() != null) {
            out.print(emptyString(indent) + "<");
            out.print(XaalConstants.COORDINATE_TAG_NAME);
            out.print(" x=\"" + s.getCoordinate().getX());
            out.print("\" y=\"" + s.getCoordinate().getY());
            out.print("\"/>\n");
        }
        // TODO Handle coordinates with complex locations

    }

    /**
     * @return
     */
    private boolean appendRef(Structure s) {
        if (s.getRef() != null) {
            out.print(" ref=\"" + s.getRef());
            out.print("\"");
            return true;
        }
        return false;
    }

    /**
     * @param c
     */
    private void appendCoordinate(Coordinate c, String tagName) {
        out.print(emptyString(indent) + "<");
        out.print(tagName);
        out.print(" x=\"" + c.getX());
        out.print("\" y=\"" + c.getY());
        out.print("\" id=\"" + c.getId() + "\"");
        if (c.getOffset() != null) {
            out.print(">\n");
            indent++;
            Offset o = c.getOffset();
            out.print(emptyString(indent) + "<offset");
            out.print(" x=\"" + o.getX());
            out.print("\" y=\"" + o.getY() + "\"");
            if (o.getBaseObj() != null) {
                out.print(" base-object=\"" + o.getBaseObj().getId() + "\"");
            }
            out.print(" anchor=\"" + o.getAnchor() + "\"/>\n");
            indent--;
            out.print(emptyString(indent) + "</");
            out.print(tagName + ">\n");
        } else {
            out.print("/>\n");
        }
    }

    /**
     * @param i
     */
    private void appendDepth(int i) {
        if (i == -1)
            return;
        out.print(emptyString(indent) + "<");
        out.print(XaalConstants.DEPTH_TAG_NAME + " value=\"");
        out.print(i + "\"/>\n");
    }

    /**
     * @param style
     */
    private void appendStyle(Style style) {
        if (style == null || doneStyles.contains(style))
            return;
        out.print(emptyString(indent) + "<");
        out.print(XaalConstants.STYLE_TAG_NAME);
        if (style.getId() != null)
            out.print(" id=\"" + style.getId() + "\"");
        if (style.getUses() != null)
            out.print(" uses=\"" + style.getUses().getId() + "\"");
        out.print(">\n");
        indent++;
        Color c = style.getColor();
        if (c != null) {
            out.print(emptyString(indent) + "<");
            out.print(XaalConstants.COLOR_TAG_NAME);
            if (useColorNames() && ColorConverter.isPredefinedColor(c)) {
                out.print(" name=\"" + ColorConverter.getPredefinedColorName(c));
            } else {
                out.print(" red=\"" + c.getRed());
                out.print("\" green=\"" + c.getGreen());
                out.print("\" blue=\"" + c.getBlue());
            }
            out.print("\"/>\n");
        }
        c = style.getFillColor();
        if (c != null) {
            out.print(emptyString(indent) + "<");
            out.print(XaalConstants.FILLCOLOR_TAG_NAME);
            if (useColorNames() && ColorConverter.isPredefinedColor(c)) {
                out.print(" name=\"" + ColorConverter.getPredefinedColorName(c));
            } else {
                out.print(" red=\"" + c.getRed());
                out.print("\" green=\"" + c.getGreen());
                out.print("\" blue=\"" + c.getBlue());
            }
            out.print("\"/>\n");
        }
        Font f = style.getFont();
        if (f != null) {
            out.print(emptyString(indent) + "<");
            out.print(XaalConstants.FONT_TAG_NAME);
            out.print(" size=\"" + f.getSize() + "\"");
            out.print(" family=\"" + f.getFamily() + "\"");
            if (f.isBold())
                out.print(" bold=\"true\"");
            if (f.isItalic())
                out.print(" italic=\"true\"");
            out.print("/>\n");
        }
        // TODO Implement rest of style to xaal xml
        indent--;
        out.print(emptyString(indent) + "</");
        out.print(XaalConstants.STYLE_TAG_NAME + ">\n");
        doneStyles.add(style);
    }


    /**
     * Appends a style attribute referencing a already handled style. If the
     * style has not been handled already, does nothing.
     * 
     * @param s The style.
     */
    private void appendStyleAttr(Style s) {
        if (s != null && doneStyles.contains(s))
            out.print(" style=\"" + s.getId() + "\"");
    }

    private void appendStyleRef(String s) {
        if (s != null)
            out.print(" style=\"" + s + "\"");
    }

    public Object convert(AnimationOperation ao) {
        /*xaal.getErrorLog().warn(
                                this,
                                "Unsupported AnimatedOperation: "
                                        + ao.getClass().getName());*/
        System.out.println("Unsupported AnimationOperation: "
                                        + ao.getClass().getName());
        return null;
    }
    
    public void convert(ChangePropertyOperation cpo) {
        out.print(emptyString(indent));
        out.print("<" + XaalConstants.CHANGEPROPERTY_TAG_NAME);
        appendId(cpo);
        out.print(">\n");
        indent++;
        if (cpo.getNarrative() != null)
            appendNarrative(cpo.getNarrative());
        Iterator iter = cpo.getGraphicals();
        while (iter.hasNext()) {
            GraphicalPrimitive gp = (GraphicalPrimitive) iter.next();
            appendObjectRef(gp);
        }
        iter = cpo.getStructures();
        while (iter.hasNext()) {
            Structure str = (Structure) iter.next();
            appendObjectRef(str);
        }
        appendTiming(cpo);
        out.print(emptyString(indent) + "<" + XaalConstants.PROPERTY_TAG_NAME);
        out.print(" type=\"" + cpo.getPropertyType() + "\"");
        out.print(" value=\"" + cpo.getPropertyValue() + "\"/>\n");
        indent--;
        out.print(emptyString(indent));
        out.print("</" + XaalConstants.CHANGEPROPERTY_TAG_NAME + ">\n");
    }

    public void convert(CreateOperation co) {
        out.print(emptyString(indent));
        out.print("<" + XaalConstants.CREATE_TAG_NAME);
        appendId(co);
        if (co.getTarget() != null)
            out.print(" target=\"" + co.getTarget().getId() + "\"");
        out.print(">\n");
        indent++;
        if (co.getNarrative() != null)
            appendNarrative(co.getNarrative());
        Iterator iter = co.getStructures();
        while (iter.hasNext()) {
            Structure s = (Structure) iter.next();
            if (s != null)
                ReflectionHelper.invoke(s, this, "convert");
        }
        iter = co.getGraphicals();
        while (iter.hasNext()) {
            GraphicalPrimitive gp = (GraphicalPrimitive) iter.next();
            if (gp != null)
                ReflectionHelper.invoke(gp, this, "convert");
        }
        indent--;
        out.print(emptyString(indent));
        out.print("</" + XaalConstants.CREATE_TAG_NAME + ">\n");
    }

    public void convert(RemoveOperation ro) {
        out.print(emptyString(indent));
        out.print("<" + XaalConstants.REMOVE_TAG_NAME);
        appendId(ro);
        out.print(" target=\"" + ro.getTarget().getId() + "\">\n");
        indent++;
        if (ro.getNarrative() != null) {
            appendNarrative(ro.getNarrative());
        }
        appendGraphicalRepresentation(ro);
        indent--;
        out.print(emptyString(indent));
        out.print("</" + XaalConstants.REMOVE_TAG_NAME + ">\n");
    }


    public void convert(InsertOperation io) {
        out.print(emptyString(indent));
        out.print("<" + XaalConstants.INSERT_TAG_NAME);
        appendId(io);
        if (io.getSource() != null)
            out.print(" source=\"" + io.getSource().getId() + "\"");
        out.print(" target=\"" + io.getTarget().getId() + "\">\n");
        indent++;
        if (io.getNarrative() != null)
            appendNarrative(io.getNarrative());
        Iterator iter = io.getStructures();
        while (iter.hasNext()) {
            Structure s = (Structure) iter.next();
            if (s != null)
                ReflectionHelper.invoke(s, this, "convert");
        }
        appendGraphicalRepresentation(io);
        indent--;
        out.print(emptyString(indent));
        out.print("</" + XaalConstants.INSERT_TAG_NAME + ">\n");
    }

    public void convert(DeleteOperation deo) {
        out.print(emptyString(indent));
        out.print("<" + XaalConstants.DELETE_TAG_NAME);
        appendId(deo);
        if (deo.getKey() != null)
            out.print(" key=\"" + deo.getKey() + "\"");
        out.print(" target=\"" + deo.getTarget().getId() + "\">\n");
        indent++;
        if (deo.getNarrative() != null)
            appendNarrative(deo.getNarrative());
        Iterator iter = deo.getStructures();
        while (iter.hasNext()) {
            Structure s = (Structure) iter.next();
            if (s != null)
                ReflectionHelper.invoke(s, this, "convert");
        }
        appendGraphicalRepresentation(deo);
        indent--;
        out.print(emptyString(indent));
        out.print("</" + XaalConstants.DELETE_TAG_NAME + ">\n");
    }

    public void convert(SearchOperation seo) {
        out.print(emptyString(indent));
        out.print("<" + XaalConstants.SEARCH_TAG_NAME);
        out.print(" target=\"" + seo.getTarget().getId());
        appendId(seo);
        if (seo.getKey() != null)
            out.print("\" key=\"" + seo.getKey());
        out.print(">\n");
        indent++;
        if (seo.getNarrative() != null)
            appendNarrative(seo.getNarrative());
        Iterator iter = seo.getStructures();
        while (iter.hasNext()) {
            Structure s = (Structure) iter.next();
            if (s != null)
                ReflectionHelper.invoke(s, this, "convert");
        }
        indent--;

        out.print("\"/>\n");
    }

    public void convert(SwapOperation swo) {
        out.print(emptyString(indent));
        out.print("<" + XaalConstants.SWAP_TAG_NAME);
        appendId(swo);
        out.print(" swap=\"" + swo.getSwap().getId());
        out.print("\" with=\"" + swo.getWith().getId());
        if (swo.getNarrative() != null) {
            out.print("\">\n");
            indent++;
            appendNarrative(swo.getNarrative());
            indent--;
            out.print(emptyString(indent));
            out.print("</" + XaalConstants.SWAP_TAG_NAME);
            out.print(">\n");
        } else
            out.print("\"/>\n");
    }

    public void convert(SwapIdOperation swo) {
        out.print(emptyString(indent));
        out.print("<" + XaalConstants.SWAPID_TAG_NAME);
        appendId(swo);
        out.print(" swap=\"" + swo.getSwap());
        out.print("\" with=\"" + swo.getWith());
        if (swo.getNarrative() != null) {
            out.print("\">\n");
            indent++;
            appendNarrative(swo.getNarrative());
            indent--;
            out.print(emptyString(indent));
            out.print("</" + XaalConstants.SWAPID_TAG_NAME);
            out.print(">\n");
        } else
            out.print("\"/>\n");
    }

    /*
     * public Object convert(RemoveOperation ro) {
     * xaal.append(emptyString(indent)); xaal.append("<remove
     * target=\"" + getId(ro.getTarget()));
     * xaal.append("\"/>\n"); return new Boolean(true); }
     */

    public void convert(SeqOperation so) {
        out.print(emptyString(indent));
        out.print("<" + XaalConstants.SEQ_TAG_NAME + ">\n");
        indent++;
        if (so.getNarrative() != null)
            appendNarrative(so.getNarrative());
        Iterator iter = so.getOperations();
        while (iter.hasNext()) {
            AnimationOperation oper = (AnimationOperation) iter.next();
            ReflectionHelper.invoke(oper, this, "convert");
        }
        indent--;
        out.print(emptyString(indent));
        out.print("</" + XaalConstants.SEQ_TAG_NAME + ">\n");

    }

    public void convert(ParOperation po) {
        out.print(emptyString(indent));
        out.print("<" + XaalConstants.PAR_TAG_NAME + ">\n");
        indent++;
        if (po.getNarrative() != null)
            appendNarrative(po.getNarrative());
        Iterator iter = po.getOperations();
        while (iter.hasNext()) {
            AnimationOperation oper = (AnimationOperation) iter.next();
            ReflectionHelper.invoke(oper, this, "convert");
        }
        indent--;
        out.print(emptyString(indent));
        out.print("</" + XaalConstants.PAR_TAG_NAME + ">\n");

    }

    private void appendNarrative(String narrative) {
        out.print(emptyString(indent));
        out.print("<" + XaalConstants.NARRATIVE_TAG_NAME + ">");
        out.print(narrative);
        out.print(emptyString(indent));
        out.print("</" + XaalConstants.NARRATIVE_TAG_NAME + ">\n");
    }
    
    
    private boolean useColorNames() {
        return false;
    }
    
    private String escapeXmlEntities(String codeline) {
        final StringBuilder result = new StringBuilder();
        final StringCharacterIterator iterator = new StringCharacterIterator(codeline);
        char character =  iterator.current();
        while (character != CharacterIterator.DONE ){
            while (character != CharacterIterator.DONE ){
                if (character == '<') {
                  result.append("&lt;");
                }
                else if (character == '>') {
                  result.append("&gt;");
                }
                else if (character == '\"') {
                  result.append("&quot;");
                }
                else if (character == '\'') {
                  result.append("&#039;");
                }
                else if (character == '&') {
                   result.append("&amp;");
                }
                else {
                  //the char is not a special one
                  //add it to the result as is
                  result.append(character);
                }
                character = iterator.next();
              }
            character = iterator.next();
        }
        return result.toString();
    }
}