source: trunk/src/org/expeditee/items/ItemUtils.java@ 1415

/**
 *    ItemUtils.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.items;

import java.io.File;
import java.io.UnsupportedEncodingException;
import java.net.URL;
import java.net.URLDecoder;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

import org.expeditee.core.Colour;
import org.expeditee.core.bounds.AxisAlignedBoxBounds;
import org.expeditee.gui.DisplayController;
import org.expeditee.gui.DisplayController.TwinFramesSide;
import org.expeditee.gui.Frame;
import org.expeditee.gui.FrameUtils;
import org.expeditee.gui.FreeItems;
import org.expeditee.gui.Vector;
import org.expeditee.items.Item.HighlightMode;
import org.expeditee.items.widgets.InteractiveWidgetInitialisationFailedException;
import org.expeditee.items.widgets.InteractiveWidgetNotAvailableException;
import org.expeditee.items.widgets.Widget;
import org.expeditee.items.widgets.WidgetCorner;
import org.expeditee.items.widgets.WidgetEdge;
import org.expeditee.network.FrameShare;
import org.expeditee.settings.folders.FolderSettings;

//Static methods that provide functions for the objects\
//mostly to transform values (string -> color etc).

/**
 * Static methods that provide functions for use in Items.
 */
public class ItemUtils {
        // Tag constants
        public static final int TAG_SORT = 0;

        public static final int TAG_JOIN = 1;

        public static final int TAG_INDENT = 2;

        public static final int TAG_OVERLAY = 3;

        public static final int TAG_ACTIVE_OVERLAY = 4;

        public static final int TAG_IMAGE = 5;

        public static final int TAG_ITEM_TEMPLATE = 6;

        public static final int TAG_ANNOTATION_TEMPLATE = 7;

        public static final int TAG_CODE_COMMENT_TEMPLATE = 8;

        public static final int TAG_MENU = 9;

        public static final int TAG_MENU_NEXT = 10;

        public static final int TAG_PARENT = 11;

        public static final int TAG_LITERAL = 12;

        public static final int TAG_FRAME_IMAGE = 13;

        public static final int TAG_BACKUP = 14;

        public static final int TAG_POINTTYPE = 15;

        // Brook: Im claiming this number!
        public static final int TAG_IWIDGET = 16;

        public static final int TAG_DOT_TEMPLATE = 17;

        public static final int TAG_STAT_TEMPLATE = 18;

        public static final int TAG_VECTOR = 19;

        public static final int TAG_ACTIVE_VECTOR = 21;

        public static final int TAG_BITMAP_IMAGE = 20;

        public static final int TAG_MIN = 0;

        public static final int TAG_MAX = 21;

        /**
         * Determines if the given List of Items contains an Item that is one of the
         * pre-defined tags.
         * 
         * @param items
         *            The list of Items to search through
         * @param tag
         *            The Tag to search for, this should correspond to one of the
         *            predefined constants in this class
         * @return True if an Item was found that is the given Tag, False otherwise.
         */
        public static boolean ContainsTag(Collection<Item> items, int tag) {
                return ContainsTag(items, GetTag(tag));
        }

        public static boolean ContainsTag(Collection<Item> items, String tag) {
                return (FindTag(items, tag) != null);
        }

        public static boolean ContainsExactTag(Collection<Item> items, int tag) {
                return ContainsExactTag(items, GetTag(tag));
        }

        public static boolean ContainsExactTag(Collection<Item> items, String tag) {
                return (FindExactTag(items, tag) != null);
        }

        /**
         * Searches the given List of Items for an Item that is one of the
         * pre-defined tags.
         * 
         * @param items
         *            The list of Items to search through
         * @param tag
         *            The Tag to search for, this should correspond to one of the
         *            predefined constants in this class
         * @return The Item that is the given tag if one is found, or False if none
         *         is found
         */
        public static Item FindTag(List<Item> items, int tag) {
                return FindTag(items, GetTag(tag));
        }

        /**
         * Searches the given List of Items for an Item that is the given tag
         * 
         * @param items
         *            The list of Items to search through
         * @param toFind
         *            The Tag to search for, this should include the at (@) symbol
         * @return The Item that is the given tag if one is found, or False if none
         *         is found
         */
        public static Text FindTag(Collection<Item> items, String toFind) {
                for (Item i : items) {
                        if (i instanceof Text && i.isAnnotation()) {
                                if (((Text) i).startsWith(toFind)) {
                                        return (Text) i;
                                }
                        }
                }
                return null;
        }

        public static Item FindExactTag(Collection<Item> items, String toFind) {
                for (Item i : items) {
                        if (i instanceof Text && i.isAnnotation()) {
                                if (((Text) i).getText().trim().equalsIgnoreCase(toFind)) {
                                        return i;
                                }
                        }
                }

                return null;
        }

        public static Item FindExactTag(List<Item> items, int tag) {
                return FindExactTag(items, GetTag(tag));
        }

        /**
         * Determines if the given Item is one of the pre-defined tags in this class
         * 
         * @param toCheck
         *            The Item to check
         * @param tag
         *            The tag to check the Item against, this should correspond to
         *            one of the constants defined in this class
         * @return True if the Item matches the given tag, false otherwise
         */
        public static boolean startsWithTag(Item toCheck, int tag) {
                return startsWithTag(toCheck, GetTag(tag));
        }

        public static boolean startsWithTag(Item toCheck, int tag, boolean hasValue) {
                return startsWithTag(toCheck, GetTag(tag), hasValue);
        }

        /**
         * Checks if the given Item begins with the desired tag (case insensitive).
         * 
         * @param toCheck
         *            The Item to check for the given tag
         * @param tag
         *            The tag to check for in the given Item
         * @param tagOnly
         *            True if the tag does not have a value
         * @return True if the tag is found in the given Item, False otherwise.
         */
        public static boolean startsWithTag(Item toCheck, String tag,
                        boolean valueAllowed) {
                if (!(toCheck instanceof Text)) {
                        return false;
                }

                Text txt = (Text) toCheck;
                String value = ItemUtils.StripTag(txt.getText(), tag);

                if (value == null) {
                        return false;
                }
                return valueAllowed || value.equals("");
        }

        /**
         * Checks if the item begins with the desired tag.
         * 
         * @param toCheck
         * @param tag
         * @return
         */
        public static boolean startsWithTag(Item toCheck, String tag) {
                return startsWithTag(toCheck, tag, true);
        }

        /**
         * Strips off the given tag from the given String, and returns wathever is
         * left. Dont put the colon after tags as it is not needed.
         * 
         * @param toStrip
         *            The String to strip the Tag from
         * @param tag
         *            The tag to remove from the String
         * @return The String that results from removing the given Tag from the
         *         given String, or null if the given String is not the given Tag
         */
        public static String StripTag(String toStrip, String tag) {
                if (toStrip == null) {
                        return null;
                }
                toStrip = toStrip.trim();
                if (!toStrip.toLowerCase().startsWith(tag.toLowerCase())) {
                        return null;
                }

                if (toStrip.length() == tag.length()) {
                        return "";
                }
                // remove tag and ensure the char is the tag separator
                char separator = toStrip.charAt(tag.length());
                if (separator != ':') {
                        return null;
                }

                if (toStrip.length() == tag.length() + 1) {
                        return "";
                }

                return toStrip.substring(tag.length() + 1).trim();
        }

        /**
         * Strips the first character from a string if it is the tag symbol and
         * returns the remainder.
         * 
         * @param toStrip
         *            the string to be stripped
         * @return the stripped version of the string.
         */
        public static String StripTagSymbol(String toStrip) {
                // there must be something left after stripping
                if (toStrip != null) {
                        toStrip = toStrip.trim();
                        if (toStrip.length() > 0) {
                                if (toStrip.charAt(0) == '@') {
                                        return toStrip.substring(1);
                                }
                        }
                }
                return toStrip;
        }

        /**
         * Converts the given int to the String tag. The int should correspond to
         * one of the constants in this class, if it does not this method will
         * return null.
         * 
         * @param tag
         *            The int corresponding to the constants in this class of which
         *            tag to return
         * @return The String representation of the given Tag, or null if the given
         *         value does not have a tag associated
         */
        public static String GetTag(int tag) {
                // TODO refactor so that this uses a map for INT to tags
                switch (tag) {
                case TAG_SORT:
                        return "@sort";
                case TAG_JOIN:
                        return "@join";
                case TAG_INDENT:
                        return "@indent";
                case TAG_OVERLAY:
                        return "@o";
                case TAG_VECTOR:
                        return "@v";
                case TAG_ACTIVE_VECTOR:
                        return "@av";
                case TAG_ACTIVE_OVERLAY:
                        return "@ao";
                case TAG_IMAGE:
                        return "@i";
                case TAG_ITEM_TEMPLATE:
                        return "@itemtemplate";
                case TAG_ANNOTATION_TEMPLATE:
                        return "@annotationtemplate";
                case TAG_STAT_TEMPLATE:
                        return "@stattemplate";
                case TAG_CODE_COMMENT_TEMPLATE:
                        return "@commenttemplate";
                case TAG_MENU:
                        return "@menu";
                case TAG_MENU_NEXT:
                        return "@nextmenu";
                case TAG_PARENT:
                        return "@parent";
                case TAG_LITERAL:
                        return "@lit";
                case TAG_FRAME_IMAGE:
                        return "@f";
                case TAG_BITMAP_IMAGE:
                        return "@b";
                case TAG_BACKUP:
                        return "@old";
                case TAG_POINTTYPE:
                        return "@pointtype";
                case TAG_IWIDGET:
                        return "@iw";
                case TAG_DOT_TEMPLATE:
                        return "@dottemplate";
                default:
                        return null;
                }
        }

        /**
         * Creates a picture object from the information stored in the given Text
         * object. <br>
         * The paths searched are in the following order:<br>
         * /images/<br>
         * the source text as a relative path (from program root folder). <br>
         * the source text as an absolute path <br>
         * <br>
         * If the Image file cannot be found on disk null is returned.
         * 
         * @param source
         *            The Text file containing the Picture information
         * @return The Picture object representing the file, or Null if the file is
         *         not found.
         */
        public static Picture CreatePicture(Text source, boolean tryRemote) {
                String text = source.getText();
                String path = "";
                String fileName = "";
                String size = "";

                try {
                        // remove @i tag
                        text = text.replaceFirst("@i:", "");
                        text = text.replaceAll("\n", "");
                        text = text.trim();

                        int fileSuffixChar = text.indexOf('.');
                        if (fileSuffixChar < 0) {
                                return null;
                        }
                        int endOfFileName = text.indexOf(' ', fileSuffixChar);
                        if (endOfFileName < 0) {
                                path = text;
                                size = "";
                        } else {
                                path = text.substring(0, endOfFileName);
                                size = text.substring(endOfFileName).trim();
                        }
                        fileName = path;

                        // try images subdirectory
                        File file = null;

                        for (String dir : FolderSettings.ImageDirs.getAbsoluteDirs()) {
                                file = new File(dir + path);
                                if (file.exists() && !file.isDirectory()) {
                                        break;
                                }
                        }

                        if (file == null || !file.exists() || file.isDirectory()) {
                                file = new File(path);
                        }

                        // try relative path
                        if (!file.exists() || file.isDirectory()) {
                                URL picture = new Object().getClass().getResource(path);

                                // decode to remove %20 in windows folder names
                                if (picture != null) {
                                        try {
                                                path = URLDecoder.decode(picture.getFile(), "UTF-8");
                                        } catch (UnsupportedEncodingException e) {
                                                // TODO Auto-generated catch block
                                                e.printStackTrace();
                                        }
                                }

                        } else {
                                path = file.getPath();
                        }

                        // if the image isn't found by now, try remote servers
                        file = new File(path);
                        if (!file.exists() || file.isDirectory()) {
                        if(tryRemote && FrameShare.getInstance().loadImage(fileName, null)) {
                                // call CreatePicture again, but with tryRemote set to false so we won't get into an infinite loop
                                // if something goes wrong with finding the downloaded image
                                return CreatePicture(source, false);
                        }
                                return null;
                        }

                } catch (Exception e) {
                        return null;
                }

                try {
                        Picture pic = new Picture(source, fileName, path, size);

                        return pic;
                } catch (Exception e) {
                        e.printStackTrace();
                        return null;
                }

        }
        
        public static Picture CreatePicture(Text source) {
                return CreatePicture(source, true);
        }

        /**
         * Creates a deep copy of the given List of Items.
         * 
         * @param toCopy
         *            The list of Items to copy
         * @return A list containing a copy of all Items in the given List
         */
        public static List<Item> CopyItems(Collection<Item> toCopy) {
                return CopyItems(toCopy, false, null);
        }

        public static List<Item> CopyItems(Collection<Item> toCopy, Vector v) {
                return CopyItems(toCopy, false, v);
        }

        public static List<Item> CopyItems(Collection<Item> toCopy, boolean extrude) {
                return CopyItems(toCopy, extrude, null);
        }

        public static List<Item> CopyItems(Collection<Item> toCopy,
                        boolean extrude, Vector v) {
                // The copies to return
                List<Item> copies = new ArrayList<Item>();

                // list of dots at the end of lines
                Collection<Item> lineEnds = new LinkedHashSet<Item>();
                Collection<Line> lines = new LinkedHashSet<Line>();
                Collection<XRayable> xrayables = new LinkedHashSet<XRayable>();
                Collection<Constraint> constraints = new LinkedHashSet<Constraint>();

                Collection<Item> singles = new LinkedHashSet<Item>();

                Map<Item, Item> lineEndMap = new HashMap<Item, Item>();

                // Widgets are super special
                List<Widget> widgets = new ArrayList<Widget>();

                for (Item i : toCopy) {
                        // Dont copy parts of a vector
                        if (i == null || !i.hasPermission(UserAppliedPermission.copy)) {
                                continue;
                        }

                        // BROOK
                        if (i instanceof WidgetCorner) { // dont add these
                                if (!widgets.contains(((WidgetCorner) i).getWidgetSource()))
                                 {
                                        widgets.add(((WidgetCorner) i).getWidgetSource());
                                // BROOK
                                }
                        } else if (i instanceof WidgetEdge) { // dont add these
                                // lines are recreated later
                        } else if (i instanceof Line) {
                                lines.add((Line) i);
                        } else if (i instanceof XRayable) {
                                xrayables.add((XRayable) i);
                        } else {
                                if (i.isLineEnd()) {
                                        lineEnds.add(i);
                                        constraints.addAll(i.getConstraints());
                                } else {
                                        singles.add(i);
                                }
                        }
                }

                // Dont copy the other items that are part of the circle
                for (XRayable x : xrayables) {
                        Collection<Item> connected = x.getConnected();
                        singles.removeAll(connected);
                        lineEnds.removeAll(connected);
                        lines.removeAll(connected);
                        Item xCopy = x.copy();
                        copies.addAll(xCopy.getConnected());
                        // Scale items that are from a vector frame
                        if (v != null) {
                                scaleItem(v, xCopy);
                        }
                }

                // copy all single items
                for (Item i : singles) {
                        Item copy = i.copy();
                        Frame parent = i.getParent();
                        if (parent != null) {
                                // Items copied from overlay will be anchored onto the current
                                // frame
                                copy.setParent(parent);
                                // if this is the frame name, make sure the frame is saved (in
                                // case it is a TDFC frame)
                                if (i.isFrameName()) {
                                        parent.setChanged(true);
                                }// check if the item is being copied from a vector
                                else if (v != null) {
                                        // Find the vector this item is from
                                        assert (v.Frame == parent);
                                        scaleItem(v, copy);
                                }
                        }
                        copies.add(copy);
                }

                // replace line ends with their copies
                // this is done here so that copied lines can still share end points
                for (Item i : lineEnds) {
                        // create a copy of the line end
                        Item copy = i.copy();
                        copy.removeAllLines();
                        copy.removeAllConstraints();

                        if (extrude) {
                                Frame frame = i.getParentOrCurrentFrame();
                                Line newLine = new Line(i, copy, frame.getNextItemID());
                                // make sure overlay items are put back on the overlay
                                newLine.setParent(frame);
                                frame.addItem(newLine);
                                copies.add(newLine);
                        }
                        copies.add(copy);
                        lineEndMap.put(i, copy);
                        // Scale items that are from a vector frame
                        if (v != null) {
                                scaleItem(v, copy);
                        }
                }

                // recreate lines
                for (Line line : lines) {
                        Line lineCopy = line.copy();
                        // get the lineEnd we copied above if it is in the MAPPING
                        Item originalLineEnd = line.getEndItem();
                        Item actualLineEnd = lineEndMap.get(originalLineEnd);
                        if (actualLineEnd == null) {
                                lineCopy.setEndItem(originalLineEnd);
                        } else {
                                lineCopy.setEndItem(actualLineEnd);
                        }

                        Item originalLineStart = line.getStartItem();
                        Item actualLineStart = lineEndMap.get(originalLineStart);
                        if (actualLineStart == null) {
                                lineCopy.setStartItem(originalLineStart);
                        } else {
                                lineCopy.setStartItem(actualLineStart);
                        }

                        copies.add(lineCopy);
                }

                // recreate constraints
                for (Constraint c : constraints) {
                        Item start = lineEndMap.get(c.getStart());
                        Item end = lineEndMap.get(c.getEnd());
                        int id = start.getParent().getNextItemID();
                        if (start != null && end != null) {
                                new Constraint(start, end, id, c.getType());
                        }
                }

                // BROOK
                for (Widget iw : widgets) {
                        try {

                                Widget icopy = iw.copy();
                                copies.addAll(icopy.getItems());

                        } catch (InteractiveWidgetNotAvailableException e) {
                                e.printStackTrace();
                        } catch (InteractiveWidgetInitialisationFailedException e) {
                                e.printStackTrace();
                        }

                }

                // Make sure filled rectangles are shown filled on vector overlays
                if (v != null) {
                        EnclosedCheck(copies);
                }

                return copies;
        }

        /**
         * Attempts to create a new line that starts from the given Item
         * ('unreeling'). The Item must already have at least one line, and not be a
         * line itself to be unreeled from.
         * 
         * @param toUnreelFrom
         *            The Item that will be one end point of the new line
         * @return A List containing the newly created Item and Line that unreel
         *         from the given Item, or null if this Item cannot be unreeled
         *         from.
         */
        public static List<Item> UnreelLine(Item toUnreelFrom, boolean constrain) {
                // the Item must already have one line to be unreeled from
                if (toUnreelFrom == null || toUnreelFrom.getLines().size() < 1) {
                        return null;
                }

                List<Item> unreel = new ArrayList<Item>(2);
                unreel.add(toUnreelFrom);
                unreel.addAll(toUnreelFrom.getLines());
                return UnreelLine(unreel, constrain);
        }

        /**
         * Attempts to create a new line that starts from the given list of Items
         * ('unreeling'). The List must contain only one non-line Item. The non-line
         * Item must already have at least one line to be unreeled from.
         * 
         * @param toUnreel
         *            The List containing the Item that will be one end point of the
         *            new line
         * @return A List of the newly created Item and Line that unreel from the
         *         Item in the given List, or null if this List cannot be unreeled
         *         from.
         */
        public static List<Item> UnreelLine(List<Item> toUnreel, boolean constrain) {
                Item origEnd = null;
                // find the end being unreeled from
                for (Item item : toUnreel) {
                        // we dont want to unreel anything other than lines
                        if (item.hasEnclosures()
                                        || !(item.isLineEnd() || item instanceof Line)) {
                                return null;
                        }
                        // find the dot to unreel from
                        if (item.isLineEnd()) {
                                // if there are multiple ends in the list, return
                                if (origEnd != null) {
                                        return null;
                                }

                                origEnd = item;
                        }
                }

                // copy the original endpoint
                Item copy = origEnd.copy();
                origEnd.setHighlightMode(HighlightMode.None);
                origEnd.setHighlightColorToDefault();
                copy.removeAllLines();
                copy.removeAllConstraints();

                for (Line l : origEnd.getLines()) {
                        l.invalidateAll();
                }

                // create a new line
                Frame currentFrame = DisplayController.getCurrentFrame();
                Line line = new Line(origEnd, copy, currentFrame.getNextItemID());
                // if the previous line was constrained then make the new line
                // constrained if it was a single line
                // TODO add later a diagonal constraint if getLines() == 3 or 4
                Collection<Constraint> constraints = origEnd.getConstraints();
                if (constrain && constraints.size() > 0 && origEnd.getLines().size() == 2) {
                        Integer type = null;
                        for (Constraint c : constraints) {
                                if (c.getType() == Constraint.HORIZONTAL) {
                                        type = Constraint.VERTICAL;
                                } else if (c.getType() == Constraint.VERTICAL) {
                                        type = Constraint.HORIZONTAL;
                                }
                                if (c.getType() == Constraint.DIAGONAL_NEG) {
                                        type = Constraint.DIAGONAL_POS;
                                } else if (c.getType() == Constraint.DIAGONAL_POS) {
                                        type = Constraint.DIAGONAL_NEG;
                                }
                        }
                        if (type != null) {
                                new Constraint(origEnd, copy, currentFrame.getNextItemID(), type);
                        }
                }

                // copy.setFloating(true);
                origEnd.setArrowheadLength(0);
                // copy.setArrowheadLength(0);

                List<Item> toReturn = new LinkedList<Item>();
                toReturn.add(copy);
                toReturn.add(line);
                return toReturn;
        }

        public static void New() {
                EnclosedCheck(DisplayController.getCurrentFrame().getSortedItems());
        }

        public static void Old() {
                OldEnclosedCheck(DisplayController.getCurrentFrame().getSortedItems());
        }

        /**
         * Updates the connectedToAnnotation flags for all items
         */
        public static void UpdateConnectedToAnnotations(Collection<Item> items) {
                // get all lineEnds on the Frame
                Collection<Item> lineEnds = new LinkedHashSet<Item>();
                for (Item i : items) {
                        i.setConnectedToAnnotation(false);
                        if (i.isLineEnd()) {
                                lineEnds.add(i);
                        }
                }

                // if there are no line endpoints on the Frame, then there can't be an
                // enclosure
                if (lineEnds.size() == 0) {
                        return;
                }

                // Now find go through line ends and see if any are annotation items
                while (lineEnds.size() > 0) {
                        Item item = lineEnds.iterator().next();
                        // If its an annotation item then set the flag for all its connected
                        // items
                        if (item.isAnnotation()) {
                                Collection<Item> connected = item.getAllConnected();
                                for (Item i : connected) {
                                        i.setConnectedToAnnotation(true);
                                }
                                lineEnds.removeAll(connected);
                        }
                        lineEnds.remove(item);
                }
        }

        /**
         * Checks through all Lines and Dots on the current Frame to detect if any
         * form an enclosure, which can then be used to manipulate items within the
         * polygon. If an enclosure is found, then the dots will have their
         * enclosure value set to true, and a List is created that contains all the
         * Dots in the order they were processed. Actual calculation of the Polygon
         * is done dynamically (to account for Dots being moved).
         */
        public static void EnclosedCheck(Collection<Item> items) {
                // get all lineEnds on the Frame
                List<Item> lineEnds = new LinkedList<Item>();
                for (Item i : items) {
                        if (i.isLineEnd()) {
                                i.setEnclosedList(null);
                                // Add line ends joined to 2 other lines
                                if (i.getLines().size() == 2) {
                                        lineEnds.add(i);
                                }
                        }
                }

                // if there are no line endpoints on the Frame, then there can't be an
                // enclosure
                if (lineEnds.size() == 0) {
                        return;
                }

                // New approach
                while (lineEnds.size() > 0) {
                        Item item = lineEnds.get(0);
                        // Get the lineEnds connected to this item
                        Collection<Item> connected = item.getAllConnected();
                        Collection<Item> connectedLineEnds = new LinkedHashSet<Item>();
                        for (Item itemToCheck : connected) {
                                if (itemToCheck.isLineEnd()) {
                                        connectedLineEnds.add(itemToCheck);
                                }
                        }
                        // Check that all the line ends are in our lineEnds list
                        int oldSize = lineEnds.size();
                        // Remove all the items from our line ends list
                        lineEnds.removeAll(connectedLineEnds);
                        int newSize = lineEnds.size();
                        int connectedSize = connectedLineEnds.size();
                        // Check if all the connectedItems were in the lineEnds collection
                        if (oldSize == newSize + connectedSize) {
                                // Set them to be the enclosed list for each of the items
                                for (Item enclosedLineEnd : connectedLineEnds) {
                                        enclosedLineEnd.setEnclosedList(connectedLineEnds);
                                }
                        }
                }
        }

        /**
         * Checks through all Lines and Dots on the current Frame to detect if any
         * form an enclosure, which can then be used to manipulate items within the
         * polygon. If an enclosure is found, then the dots will have their
         * enclosure value set to true, and a List is created that contains all the
         * Dots in the order they were processed. Actual calculation of the Polygon
         * is done dynamically (to account for Dots being moved).
         */
        public static void OldEnclosedCheck(Collection<Item> items) {
                _seen.clear();

                // get all lineEnds on the Frame
                List<Item> lineEnds = new ArrayList<Item>(0);
                for (Item i : items) {
                        if (i.isLineEnd()) {
                                i.setEnclosedList(null);

                                if (i.getLines().size() == 2) {
                                        lineEnds.add(i);
                                }
                        }
                }

                // if there are no line endpoints on the Frame, then there can't be an
                // enclosure
                if (lineEnds.size() == 0) {
                        return;
                }

                // TODO optimise this code!!
                // iterate through all the lineEnds
                for (Item searchFor : lineEnds) {
                        _seen.clear();

                        for (Line l : searchFor.getLines()) {
                                _seen.add(l);
                                if (traverse(searchFor, l.getOppositeEnd(searchFor))) {
                                        _path.add(l.getOppositeEnd(searchFor));

                                        for (Item i : _path) {
                                                i.setEnclosedList(_path);
                                        }

                                        _path = new ArrayList<Item>(0);

                                        break;
                                }
                        }
                }
        }

        private static List<Line> _seen = new ArrayList<Line>();

        private static List<Item> _path = new ArrayList<Item>();

        private static boolean traverse(Item toFind, Item searchFrom) {
                if (toFind == null || searchFrom == null || !searchFrom.isLineEnd()) {
                        return false;
                }

                if (searchFrom.getLines().size() != 2) {
                        return false;
                }

                if (toFind == searchFrom) {
                        return true;
                }

                for (Line l : searchFrom.getLines()) {
                        if (!(_seen.contains(l))) {
                                _seen.add(l);
                                if (traverse(toFind, l.getOppositeEnd(searchFrom))) {
                                        _path.add(l.getOppositeEnd(searchFrom));
                                        return true;
                                }
                        }

                }

                return false;
        }

        /**
         * Determines if an item is visible from a the current frame(s). If the item
         * is free then it is considered visible.
         * 
         * @param i
         *            The item to check
         * @return True if visible/free from given frame.
         */
        public static boolean isVisible(Item i) {
                if (DisplayController.isTwinFramesOn()) {
                        if (!isVisible(DisplayController.getFrameOnSide(TwinFramesSide.LEFT), i)) {
                                return isVisible(DisplayController.getFrameOnSide(TwinFramesSide.RIGHT), i);
                        } else {
                                return true;
                        }
                } else {
                        return isVisible(DisplayController.getCurrentFrame(), i);
                }
        }

        /**
         * Determines if an item is visible from a given frame. If the item is free
         * then it is considered visible.
         * 
         * @param fromFrame
         *            The frame to check from.
         * @param i
         *            The item to check
         * @return True if visible/free from given frame.
         */
        public static boolean isVisible(Frame fromFrame, Item i)
        {
                if (fromFrame == null) {
                        return false;
                }

                Frame parent = i.getParent();

                if (parent == fromFrame) {
                        return true;
                } else if (parent == null) {
                        return FreeItems.getInstance().contains(i) || FreeItems.getCursor().contains(i);
                }
                
                return fromFrame.getAllItems().contains(i) && i.isVisible();
        }

        public static AxisAlignedBoxBounds expandRectangle(AxisAlignedBoxBounds r, int n)
        {
                if (r == null) {
                        return null;
                }
                
                return new AxisAlignedBoxBounds(r.getMinX() - (n >> 1), r.getMinY() - (n >> 1), r.getWidth() + n, r.getHeight() + n);
        }

        /*
         * FrameMouseActions while (!copies.isEmpty()) { Iterator<Item> iterator =
         * copies.iterator(); Item item = iterator.next(); // Dont paint annotation
         * items for @v if (!item.isVisible() || item.isAnnotation()) {
         * iterator.remove(); continue; }
         * 
         * if (!(item instanceof Line)) { item.setThickness(item.getThickness() *
         * scale); if (item instanceof XRayable || item.hasEnclosures()) {
         * scaleItem(scale, defaultForeground, defaultBackground, origin.x,
         * origin.y, item); items.add(item); copies.remove(item); } else {
         * Collection<Item> connected = item.getAllConnected(); // Get all the
         * connected items because we can only set the // thickness ONCE for (Item i :
         * connected) { scaleItem(scale, defaultForeground, defaultBackground,
         * origin.x, origin.y, i); } items.addAll(connected);
         * copies.removeAll(connected); } } else { iterator.remove(); } }
         */

        /**
         * @param scale
         * @param defaultForeground
         * @param defaultBackground
         * @param originX
         * @param originY
         * @param item
         */
        private static void scaleItem(Vector v, Item item) {
                Float scale = v.Scale;
                int originX = v.Origin.getX();
                int originY = v.Origin.getY();
                Colour defaultForeground = v.Foreground;
                Colour defaultBackground = v.Background;
                UserAppliedPermission permission = v.permission;
                // TODO should this be checking if the frame has the
                // same permissions as the vector
                // and if so don't set the item's permissions?
                item.setOverlayPermission(permission);

                // TODO encapsulate this somewhere inside of circle class!
                // if(item instanceof Circle){
                // scaleItem(v, ((Circle)item).getCenter());
                // }

                if (!(item instanceof Line)) {
                        if (item.getColor() == null) {
                                item.setColor(defaultForeground);
                        }
                        if (item.getBackgroundColor() == null) {
                                item.setBackgroundColor(defaultBackground);
                        }
                        if (item.getFillColor() == null) {
                                item.setFillColor(defaultBackground);
                        }

                        if (permission.equals(UserAppliedPermission.none)) {
                                item.setLinkMark(false);
                                item.setActionMark(false);
                        }

                        item.scale(scale, originX, originY);
                }
        }

        /**
         * Extracts widgets from an item list.
         * 
         * @param items
         *            Items to extract from. Must not be null.
         * 
         * @return List of (unique)widgets in items. Never null.
         */
        public static List<Widget> extractWidgets(List<Item> items) {
                assert (items != null);

                List<Widget> iWidgets = new LinkedList<Widget>();

                for (Item i : items) {
                        if (i instanceof WidgetEdge) {
                                WidgetEdge we = (WidgetEdge) i;
                                if (!iWidgets.contains(we.getWidgetSource())) {
                                        iWidgets.add(we.getWidgetSource());
                                }
                        } else if (i instanceof WidgetCorner) {
                                WidgetCorner wc = (WidgetCorner) i;
                                if (!iWidgets.contains(wc.getWidgetSource())) {
                                        iWidgets.add(wc.getWidgetSource());
                                }
                        }
                }

                return iWidgets;
        }
        
        /**
         * Wraps any text items to the size of their container, or the frame size if they have not container
         * 
         * @param items A list of Items to wrap (non-Text items are ignored)
         */
        public static void Justify(Collection<Item> items) {
                for (Item i : items) {
                        if (i instanceof Text) {
                                Collection<Item> enclosure = FrameUtils.getEnclosingLineEnds(i.getPosition());
                                ((Text)i).justify(false, enclosure != null ? enclosure.iterator().next().getEnclosedShape() : null);
                        }
                }
        }
        
        /**
         * Recalculates containers on the frame, then wraps all text items
         * 
         * @param frame
         */
        public static void Justify(Frame frame)
        {
                if (frame == null) {
                        return;
                }
                EnclosedCheck(frame.getSortedItems());
                Justify(frame.getSortedItems());
        }
}