source: trunk/src/org/expeditee/agents/Format.java@ 48

package org.expeditee.agents;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

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

/**
 * A simple formatting agent that aligns all non-annotation Items on the given
 * Frame by the X and Y axis of the first Item on the Frame. This agent
 * separates the items into columns, the actual alignment is done by
 * FrameUtils.Align()
 * 
 * @author jdm18
 * 
 */
public class Format extends DefaultAgent {
        // whether the Items could be formatted successfully
        private boolean _success = true;

        // adjustmen from the default format spacing
        private int _adjust = 0;

        public Format() {
        }

        public Format(String param) {
                try {
                        if (param.startsWith("+"))
                                param = param.substring(1);
                        _adjust = Integer.parseInt(param);
                } catch (Exception e) {
                        e.printStackTrace();
                }

        }

        @Override
        public Frame process(Frame start) {
                ArrayList<Item> columnHeads = new ArrayList<Item>();

                ArrayList<ArrayList<Item>> columns = new ArrayList<ArrayList<Item>>();
                for (int j = 0; j < start.getItems().size(); j++) {
                        Item i = start.getItems().get(j);

                        if (j > 0 && start.isNormalTextItem(i)) {
                                int col = findColumn(columnHeads, i);
                                // if this is the head of a new column
                                if (col < 0) {
                                        columnHeads.add(i);
                                        columns.add(new ArrayList<Item>());
                                        // otherwise the column for this item has already been
                                        // found set the column to be the one we just added...
                                        col = columns.size() - 1;
                                } else
                                        columns.get(col).add(i);
                        }
                }

                // check for empty columns
                int[] clear = new int[columnHeads.size()];
                for (int i = 0; i < columns.size(); i++)
                        clear[i] = columns.get(i).size();

                // remove empty columns
                for (int i = (clear.length - 1); i >= 0; i--)
                        if (clear[i] == 0) {
                                columns.remove(i);
                                columnHeads.remove(i);
                        }

                // if there are no columns to align, we are done
                if (columns.size() == 0)
                        return null;

                // sort the column heads by X position
                Collections.sort(columnHeads, new Comparator<Item>() {
                        public int compare(Item o1, Item o2) {
                                return o1.getX() - o2.getX();
                        }

                });

                // sort lists by their X axis
                Collections.sort(columns, new Comparator<ArrayList<Item>>() {
                        public int compare(ArrayList<Item> o1, ArrayList<Item> o2) {
                                if (o2.size() == 0)
                                        return -10;

                                if (o1.size() == 0)
                                        return 10;

                                Item i1 = o1.get(0);
                                Item i2 = o2.get(0);

                                return (i1.getX() - i2.getX());
                        }

                });

                int res = FrameUtils.Align(columns.get(0), true, _adjust);
                _success = _success && (res >= 0);

                for (int i = 0; i < columns.size() - 1; i++) {
                        List<Item> list = columns.get(i);

                        int maxX = 0;
                        int maxY = 0;
                        for (Item item : list) {
                                maxX = Math.max(maxX, item.getX() + item.getBoundsWidth());
                                maxY = Math.max(maxY, item.getY() + item.getBoundsHeight());
                        }

                        int xCheck = maxX;
                        for (Item item : columns.get(i + 1))
                                xCheck = Math.max(xCheck, maxX
                                                + /* item.getX() + */item.getBoundsWidth());

                        if (xCheck < FrameGraphics.getMaxSize().width) {
                                if (columnHeads.get(i + 1).getX() < maxX
                                                && columnHeads.get(i + 1).getY() < maxY)
                                        columnHeads.get(i + 1).setX(maxX);

                                for (Item item : columns.get(i + 1))
                                        if (item.getX() < maxX && item.getY() < maxY)
                                                item.setX(maxX);
                        }

                        res = FrameUtils.Align(columns.get(i + 1), true, _adjust);
                        _success = _success && (res >= 0);
                }

                // align all the separate columns
                /*
                 * for(ArrayList<Item> l : columns){ int res = FrameUtils.Align(l,
                 * true); _success = _success && (res >= 0); }
                 */
                start.setChanged(true);
                FrameGraphics.Repaint();
                return null;
        }

        /**
         * Finds which column contains the given Item, and returns the index to the
         * column in the start & end lists. Returns -1 if no column is found that
         * contains the given Item.
         * 
         * @param toFind
         *            The Item to determine the correct column for
         * @return The index of the column in the lists, or -1 if no column is found
         */
        private int findColumn(ArrayList<Item> columnHeads, Item toFind) {
                for (Item top : columnHeads)
                        if (FrameUtils.inSameColumn(top, toFind))
                                return columnHeads.indexOf(top);

                return -1;
        }

        @Override
        protected void finalise(Frame start) {
                 if(_success) overwriteMessage("Formating complete.");
        }

}