source: trunk/org/expeditee/io/DefaultTreeWriter.java@ 4

package org.expeditee.io;

import java.io.IOException;
import java.util.List;
import java.util.Stack;

import org.expeditee.gui.Frame;
import org.expeditee.gui.FrameGraphics;
import org.expeditee.gui.FrameIO;
import org.expeditee.items.Item;

public abstract class DefaultTreeWriter extends DefaultFrameWriter implements
                TreeWriter {

        // the list of frames currently being processed
        private Stack<FrameCounter> _frames = new Stack<FrameCounter>();

        private int _frameCount = 0;

        public String writeTree(Frame toWrite) throws IOException {
                try {
                        initialise(toWrite);

                        outputTree(toWrite);

                        _running = false;
                        return finaliseTree();
                } catch (IOException ioe) {
                        _running = false;
                        throw ioe;
                }
        }

        /**
         * This method is used to output any tags before following the Item's link
         * when using tree writers.
         * 
         * @param linker
         *            The linked Item that is about to be followed.
         * @throws IOException
         */
        protected void writeStartLink(Item linker) throws IOException {

        }

        /**
         * This method is called after the Frame the Item links to has been
         * processed. This allows end tags to be written if the format requires it.
         * 
         * @param linker
         *            The Item whose link was just followed.
         * @throws IOException
         */
        protected void writeEndLink(Item linker) throws IOException {

        }

        protected void resumeFrame(Frame resuming) {
        }

        protected void outputTree(Frame toWrite) throws IOException {
                if (toWrite == null)
                        return;

                _frames.push(new FrameCounter(toWrite.getFrameName(), -1));

                // process the entire tree of frames in depth-first order
                while (_frames.size() > 0) {
                        FrameCounter cur = _frames.pop();

                        Frame next = FrameIO.LoadFrame(cur.frame);
                        if (next == null) {
                                return;
                        }

                        // the items on the frame currently being processed.
                        List<Item> items = next.getItems();

                        // write any information relating to the end of the link
                        if (cur.index > 0) {
                                this.writeEndLink(items.get(cur.index));
                                this.resumeFrame(next);
                        } else {
                                FrameGraphics.OverwriteMessage("Writing: "
                                                + next.getFrameName());
                                _frameCount++;
                                writeStartFrame(next);
                        }

                        boolean complete = true;

                        // resume from the next item in the list
                        for (int i = cur.index + 1; i < items.size(); i++) {
                                if (_stop)
                                        return;

                                Item item = items.get(i);

                                // ignore annotation and framenames
                                if (item.getID() >= 0) {
                                        if (item.getLink() != null && !item.isAnnotation()) {
                                                cur.index = i;
                                                _frames.push(cur);

                                                // write any information relating to the start of the
                                                // link
                                                this.writeStartLink(item);

                                                Frame linked = FrameIO.LoadFrame(item.getLink());

                                                // if the linked frame was found, then display it next
                                                if (linked != null) {
                                                        FrameCounter fc = new FrameCounter(linked
                                                                        .getFrameName(), -1);
                                                        if (!_frames.contains(fc)) {
                                                                // remember what frame we are on before
                                                                // processing it
                                                                _frames.push(fc);

                                                                complete = false;
                                                                // process the loaded frame immediately
                                                                // (depth-first)
                                                                break;
                                                        }
                                                }
                                        } else if (item != next.getTitle())
                                                this.writeItem(item);
                                }
                        }

                        if (complete)
                                writeEndFrame(next);
                }
        }

        protected String finaliseTree() throws IOException {
                return "Tree of " + _frameCount + " frames" + finalise();
        }

        /**
         * Inner class used to keep track of what frames have been seen, as well as
         * what Item in the Frame the processing was up to. Only Frame names are
         * stored to keep memory usage down.
         */
        private class FrameCounter {
                public int index;

                public String frame;

                public FrameCounter(String f, int i) {
                        frame = f.toLowerCase();
                        index = i;
                }

                @Override
                public boolean equals(Object o) {
                        if (o instanceof FrameCounter)
                                return (((FrameCounter) o).frame.equals(frame));// && fc.index
                                                                                                                                // == index);

                        return false;
                }
        }
}