source: trunk/src/org/expeditee/io/DefaultTreeWriter.java@ 1529

/**
 *    DefaultTreeWriter.java
 *    Copyright (C) 2010 New Zealand Digital Library, http://expeditee.org
 *
 *    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 org.expeditee.io;

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

import org.expeditee.gui.Frame;
import org.expeditee.gui.FrameIO;
import org.expeditee.gui.MessageBay;
import org.expeditee.io.flowlayout.XGroupItem;
import org.expeditee.items.Item;
import org.expeditee.items.Text;

public abstract class DefaultTreeWriter extends DefaultFrameWriter implements
                TreeWriter {

        private int _indent = 0;

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

        private int _frameCount = 0;

        public int getFrameCount() {
                return _frameCount;
        }

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

                } catch (IOException ioe) {
                        _running = false;
                        throw ioe;
                } catch (Exception e) {
                        e.printStackTrace();
                }
                _running = false;
                return finaliseTree();
        }

        /**
         * 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 {
                _indent++;
        }

        /**
         * 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 {
                _indent--;
        }

        protected void resumeFrame(Frame resuming) {
        }

        protected List<Item> getSortedItems(Frame frame) 
        {
                List<Item> items = frame.getSortedItems();
                return items;
        }
        
        protected void outputTree(Frame toWrite) throws IOException {
                if (toWrite == null) {
                        return;
                }
                
                XGroupItem.doImplicitBoxing = false;
                
                _frames.push(new FrameCounter(toWrite.getName(), -1));

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

                        if (_stop)
                                return;

                        Frame next = FrameIO.LoadFrame(cur.frame);

                        if (next == null) {
                                return;
                        }

                        Text title = next.getTitleItem();

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

                        // write any information relating to the end of the link
                        if (cur.index > 0) {
                                this.writeEndLink(items.get(cur.index));
                                this.resumeFrame(next);
                        } else {
                                MessageBay.overwriteMessage("Writing: " + next.getName());
                                _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) {
                                        // Only follow the links of non annotation text items
                                        boolean followLink = item instanceof Text
                                                        && item.getLink() != null
                                                        && (!item.isAnnotation() /*|| item.getText()
                                                                        .toLowerCase().equals("@next")*/);

                                        if (followLink) {
                                                cur.index = i;
                                                _frames.push(cur);

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

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

                                                // if the linked frame was found, then display it next
                                                if (linked != null) {
                                                        FrameCounter fc = new FrameCounter(
                                                                        linked.getName(), -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;
                                                        }
                                                }
                                                // Don't write out the title here because it is written
                                                // out earlier
                                        } else if (item != title)
                                                this.writeItem(item);
                                }
                        }

                        if (complete)
                                writeEndFrame(next);
                }
        }

        protected void outputTreeFlowWalkerStyle(Frame toWrite) {
                XGroupItem.doImplicitBoxing = true;
                XGroupItem xgroup = new XGroupItem(toWrite, new ArrayList<Item>(toWrite.getAllItems()));
                xgroup.repositionOutOfFlowGroups(xgroup);
                xgroup.mapInXGroupItemsRecursive(xgroup.getGroupedItemList());
                
                ArrayList<Item> yxOverlappingItemList = xgroup.getYXOverlappingItemList();
                
                for(Item i: yxOverlappingItemList) {
                        if (i instanceof Text) {
                                Text t = (Text) i;
                                if (t.isAnnotation()) { continue; }
                                Text titleItem = t.getParent().getTitleItem();
                                if (t.equals(titleItem)) { continue; }
                                if (t.hasLink()) {
                                        Frame toWalk = FrameIO.LoadFrame(t.getAbsoluteLink());
                                        outputTreeFlowWalkerStyle(toWalk);
                                        continue;
                                }
                                try {
                                        this.writeItem(t);
                                } catch (IOException e) {
                                        System.err.println("DefaultTreeWriter::outputTreeFlowWalkerStyle::IOException while writing item.");
                                        System.err.println(e.getMessage());
                                }
                        }
                }
        }
        
        protected String finaliseTree() throws IOException {
                return "Tree" + 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;
                }
        }

        protected int getIndent() {
                return _indent;
        }
}