source: trunk/src/org/expeditee/items/Item.java@ 1505

/**
 *    Item.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.util.ArrayList;
import java.util.Collection;
import java.util.ConcurrentModificationException;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.expeditee.actions.Actions;
import org.expeditee.actions.IncorrectUseOfStatementException;
import org.expeditee.actions.Javascript;
import org.expeditee.actions.Misc;
import org.expeditee.actions.Simple;
import org.expeditee.core.Anchoring;
import org.expeditee.core.Colour;
import org.expeditee.core.Cursor;
import org.expeditee.core.Dimension;
import org.expeditee.core.Fill;
import org.expeditee.core.Font;
import org.expeditee.core.GradientFill;
import org.expeditee.core.Point;
import org.expeditee.core.Stroke;
import org.expeditee.core.bounds.AxisAlignedBoxBounds;
import org.expeditee.core.bounds.Bounds;
import org.expeditee.core.bounds.EllipticalBounds;
import org.expeditee.core.bounds.PolygonBounds;
import org.expeditee.encryption.core.EncryptedImage;
import org.expeditee.encryption.items.KeyType;
import org.expeditee.encryption.items.surrogates.EncryptionDetail;
import org.expeditee.encryption.items.surrogates.EncryptionDetail.Type;
import org.expeditee.encryption.items.surrogates.Label.LabelInfo;
import org.expeditee.encryption.items.surrogates.Label.LabelResult;
import org.expeditee.encryption.items.surrogates.Label;
import org.expeditee.gio.EcosystemManager;
import org.expeditee.gio.GraphicsManager;
import org.expeditee.gio.gesture.StandardGestureActions;
import org.expeditee.gui.AttributeValuePair;
import org.expeditee.gui.DisplayController;
import org.expeditee.gui.Frame;
import org.expeditee.gui.FrameIO;
import org.expeditee.gui.FrameUtils;
import org.expeditee.gui.FreeItems;
import org.expeditee.gui.MessageBay;
import org.expeditee.gui.Overlay;
import org.expeditee.gui.Vector;
import org.expeditee.io.Conversion;
import org.expeditee.io.DefaultFrameWriter;
import org.expeditee.settings.UserSettings;
import org.expeditee.settings.legacy.LegacyFeatures;
import org.expeditee.simple.Context;
import org.expeditee.stats.AgentStats;
import org.expeditee.stats.Formatter;
import org.mozilla.javascript.Scriptable;
import org.mozilla.javascript.ScriptableObject;

/**
 * Represents everything that can be drawn on the screen (text, lines, dots,
 * images). Each specific type is a subclass of Item.
 * 
 * @author jdm18
 * 
 */
public abstract class Item implements Comparable<Item>, Runnable {

        public enum HighlightMode {
                None, // The item has no highlighting
                Enclosed, // The item is part of the current enclosure
                Connected, // The item is connected to the current item
                Disconnect, // The item is a free item
                Normal // The item is the current item
        }

        /** Which edge of the window things are anchored to. */
        public enum AnchorEdgeType {
                None, Left, Right, Top, Bottom
        }
        
        public static final float SIZE_NOT_APPLICABLE = Float.NaN;
        
        public static final Float DEFAULT_THICKNESS = 2f;

        public static final Float MINIMUM_THICKNESS = 0f;

        public static final Float MINIMUM_PAINT_THICKNESS = 1f;

        protected static final Stroke.JOIN DEFAULT_JOIN = Stroke.JOIN.ROUND;

        protected static final Stroke.CAP DEFAULT_CAP = Stroke.CAP.BUTT;

        protected static final Stroke DOT_STROKE = new Stroke(DEFAULT_THICKNESS, DEFAULT_CAP, DEFAULT_JOIN);

        protected static final Stroke HIGHLIGHT_STROKE = new Stroke(MINIMUM_THICKNESS, DEFAULT_CAP, DEFAULT_JOIN);
        
        public static final int LEFT_MARGIN = 13;

        public static final int NEAR_DISTANCE = 15;

        public static final int DEFAULT_HIGHLIGHT_THICKNESS = 2;

        /** The default colour to draw highlighting in */
        public static final Colour DEFAULT_HIGHLIGHT = Colour.RED;

        public static final Colour DEPRESSED_HIGHLIGHT = Colour.GREEN;

        public static final Colour ALTERNATE_HIGHLIGHT = Colour.BLUE;

        public static final Colour LINK_COLOR = Colour.BLACK;

        public static final Colour ACTION_COLOR = Colour.BLACK;

        public static final Colour LINK_ACTION_COLOR = Colour.RED;

        public static final Colour DEFAULT_FOREGROUND = Colour.BLACK;

        public static final Colour DEFAULT_BACKGROUND = Colour.WHITE;

        public static final Colour TRANSPARENT = new Colour(0, 0, 0, 0);

        /** The number of pixels highlighting should extend around Items. */
        public static final int XGRAVITY = 3;

        public static final int MARGIN_RIGHT = 2;

        public static final int MARGIN_LEFT = 15;

        protected static final double DEFAULT_ARROWHEAD_RATIO = 0.3; // used to be 0.5

        public static final double DEFAULT_ARROWHEAD_NIB_PERC  = 0.75;
        
        public static final Colour GREEN = Colour.GREEN.darker();

        //public static final int UNCHANGED_CURSOR = -100;

        public static final Cursor.CursorType DEFAULT_CURSOR = Cursor.CursorType.DEFAULT;

        public static final Cursor.CursorType HIDDEN_CURSOR = Cursor.CursorType.CUSTOM;

        public static final Cursor.CursorType TEXT_CURSOR = Cursor.CursorType.TEXT;

        public static final Cursor.CursorType CROP_CURSOR = Cursor.CursorType.CROSSHAIR;
        
        /** The default value for integer attributes */
        public static final int DEFAULT_INTEGER = -1;
        
        private static final int BRIGHTNESS = 185;
        
        /** Contains all dots (including this one) that form an enclosure if this dot is part of an enclosing shape. */
        private Collection<Item> _enclosure = null;

        /** The area which this item covers (including its gravity). */
        private Bounds _bounds = null;
        
        /** The area this item covered before it was invalidated. */
        private Bounds _oldBounds = null;

        protected boolean _connectedToAnnotation = false;

        protected boolean _save = true;

        /** The angle of change for gradient colour fills (in radians). */
        private double _gradientAngle = 0.0;
        
        private Tooltip _tooltip = new Tooltip();

        protected Anchoring _anchoring = new Anchoring();

        /** The highlight mode for this item. */
        protected HighlightMode _highlightMode = HighlightMode.None;

        private Point _offset = new Point(0, 0);

        protected float _x;
        protected float _y;

        private int _id;

        private Item _editTarget = this;

        private String _creationDate = null;

        /** Whether or not this item should display a mark indicating it has a link. */
        private boolean _linkMark = true;

        /** Whether or not this item should display a mark indicating it has an action. */
        private boolean _actionMark = true;

        /** TODO: Appears unused? cts16 */
        private boolean _highlight = true;

        // private int _maxWidth = -1;

        private String _owner = null;

        private String _link = null;
        
        private boolean _linkHistory = true;

        private StringBuffer _tag = new StringBuffer();

        private List<String> _actionCursorEnter = null;

        private List<String> _actionCursorLeave = null;

        private List<String> _actionEnterFrame = null;

        private List<String> _actionLeaveFrame = null;

        private PermissionTriple _permissionTriple = null;
        
        private UserAppliedPermission _overlayPermission = null;

        /** The primary fill colour of this item. A fill colour of null represents transparent. */
        private Colour _fillColour = null;

        /** The secondary fill colour if this item has a gradient fill. Null represents no gradient. */
        private Colour _gradientColour = null;

        /** The primary draw colour of this item. Null represents the default colour. */
        private Colour _foregroundColour = null;

        /** The colour to draw highlights on this item. */
        protected Colour _highlightColour = DEFAULT_HIGHLIGHT;

        /** The background colour for this item. */
        private Colour _backgroundColour = null;

        private Colour _colorBorder = null;

        private Colour _colorTopShadow = null;

        private Colour _colorBottomShadow = null;

        /** The shape representing the circle drawn next to link/action items. */
        private static EllipticalBounds _linkCircle = null;

        /** The shape representing the cross drawn next to invalid links. */ 
        private static PolygonBounds _linkCircleCross = null;

        private Frame _parent = null;
        private Frame _oldParent = null;

        protected int _highlightThickness = 2;

        protected int _vectorHighlightThickness = 1;

        // arrowhead parameters
        private float  _arrowheadLength  = 0;
        private double _arrowheadRatio   = DEFAULT_ARROWHEAD_RATIO;
        private double _arrowheadNibPerc = DEFAULT_ARROWHEAD_NIB_PERC;
        
        private PolygonBounds _arrowhead = null;

        // the list of lines that this point is part of.
        private List<Line> _lines = new ArrayList<Line>();

        private int[] _linePattern = null;

        private boolean _floating = false;

        // list of points constrained with this point
        private List<Constraint> _constraints = new ArrayList<Constraint>();

        private List<String> _actions = null;
         
        private String _formula = null;

        private String _link_frameset = null;

        private String _link_template = null;

        private String _fillPattern = null;

        private boolean _visible = true;

        private float _thickness = -1.0F;

        protected Collection<XRayable> _enclosures = new HashSet<XRayable>();

        private boolean _deleted = false;

        private Overlay _overlay = null;

        protected AttributeValuePair _attributeValuePair = null;

        private Float _autoStamp = null;
        
        private Item _magnetizedItemLeft = null;
        
        private Item _magnetizedItemRight = null;
        
        private Item _magnetizedItemTop = null;
        
        private Item _magnetizedItemBottom = null;
        
        private String _encryptionLabel = null;

        protected DotType _type = DotType.square;

        protected boolean _filled = true;
        
        private Data _data = new Data();
        
        // Used via reflection by AttributeUtils to determine if the boolean value is different from default.
        public static final boolean acceptsKeyboardEnterDefault = false;
        private boolean _acceptsKeyboardEnter = acceptsKeyboardEnterDefault;

        private Item surrogateFor = null;
        private Set<Item> surrogateItems = new HashSet<Item>();
        private static Map<String, EncryptionDetail> primaryPropertyEncryptionDefault = new HashMap<String, EncryptionDetail>();
        private static Map<String, Boolean> surrogatePropertyInheritanceDefault = new HashMap<String, Boolean>();
        protected Map<String, EncryptionDetail> primaryPropertyEncryption = new HashMap<String, EncryptionDetail>(primaryPropertyEncryptionDefault);
        protected Map<String, Boolean> surrogatePropertyInheritance = new HashMap<String, Boolean>(surrogatePropertyInheritanceDefault);

        private KeyType keyType = KeyType.NotAKey;
        
        {
                EncryptionDetail unencryptedOnSave = new EncryptionDetail(EncryptionDetail.Type.UnencryptedOnSave);
                for (String tag: DefaultFrameWriter.getItemTags().keySet()) {
                        if (tag == "T" || tag == "S") {
                                surrogatePropertyInheritanceDefault.put(tag, false);
                        } else {
                                surrogatePropertyInheritanceDefault.put(tag, true);
                        }
                        primaryPropertyEncryptionDefault.put(tag, unencryptedOnSave);
                }
        }
        
        /** Just calls source.duplicateOnto(dest). */
        public static void DuplicateItem(Item source, Item dest)
        {
                if (source == null) return;
                
                source.duplicateOnto(dest);
        }
        
        /** Sets the properties of dest so that they match this item's properties. */
        public void duplicateOnto(Item dest)
        {
                if (dest == null) return;
                
                dest.setX(this.getX());
                dest.setY(this.getY());

                dest.setActions(this.getAction());
                dest.setActionCursorEnter(this.getActionCursorEnter());
                dest.setActionCursorLeave(this.getActionCursorLeave());
                dest.setActionEnterFrame(this.getActionEnterFrame());
                dest.setActionLeaveFrame(this.getActionLeaveFrame());
                dest.setActionMark(this.getActionMark());

                dest.setBackgroundColor(this.getBackgroundColor());
                dest.setBottomShadowColor(this.getBottomShadowColor());
                dest.setColor(this.getColor());
                dest.setBorderColor(this.getBorderColor());

                dest.setTooltips(this.getTooltip());
                dest.setData(this.getData());
                dest.setTag(this.getTag());
                dest.setFillColor(this.getFillColor());
                dest.setGradientColor(this.getGradientColor());
                dest.setGradientAngle(this.getGradientAngle());
                dest.setFillPattern(this.getFillPattern());

                dest.setHighlight(this.getHighlight());
                dest.setLink(this.getLink());
                dest.setLinkFrameset(this.getLinkFrameset());
                dest.setLinkMark(this.getLinkMark());
                dest.setLinkTemplate(this.getLinkTemplate());

                // dest.setWidth(this.getWidth());

                dest.setOffset(this.getOffset());
                // dest.setOwner(this.getOwner());
                dest.setThickness(this.getThickness());
                dest.setSize(this.getSize());
                dest.setTopShadowColor(this.getTopShadowColor());
                dest.setLinePattern(this.getLinePattern());

                dest.setFloating(this.isFloating());
                dest.setArrow(this.getArrowheadLength(), this.getArrowheadRatio(), this.getArrowheadNibPerc());
                dest.setDotType(this.getDotType());
                dest.setFilled(this.getFilled());
                /*
                 * Calling the methods will move the item... This messes things up when
                 * the user uses backspace to delete a text line end
                 */
                // dest._anchorLeft = this._anchorLeft;
                // dest._anchorRight = this._anchorRight;
                // dest._anchorTop = this._anchorTop;
                // dest._anchorBottom = this._anchorBottom;
                dest.setFormula(this.getFormula());
                dest._overlay = this._overlay;
                dest._highlightMode = this._highlightMode;// SelectedMode.None;
                // dest._highlightColor = this._highlightColor;
                // dest.setHighlight(this.getHighlight());

                dest._visible = this._visible;

                Frame parent = DisplayController.getCurrentFrame();
                if (parent == null) parent = this.getParentOrCurrentFrame();
                dest.setParent(parent);

                /*
                 * TODO MIKE says maybe we could tighten up and only give items ID's if
                 * their current ID is negative?
                 */
                if (parent != null) {
                        dest.setID(parent.getNextItemID());
                }
                
                String currentUser = UserSettings.UserName.get();
//              if (parent != null && !currentUser.equals(parent.getOwner())) {
//                      //dest.setOwner(currentUser);
//              } else {
//                      System.err.println("I have duplicated a item and made it owned by "
//                                      + "current user, whereas the old code would not have "
//                                      + "changed ownership at this time.");
//                      System.err.println("Item: " + dest + ", Class: " + dest.getClass());
//                      System.err.println("Current owner: " + dest.getOwner());
//                      System.err.println("Current user: " + currentUser);
//              }
                dest.setOwner(currentUser);
        }
        
        public void setDotType(DotType type) {
                invalidateAll();
                _type = type;
                invalidateAll();
                if (isSurrogate()) {
                        surrogatePropertyInheritance.put(DefaultFrameWriter.DOT_TYPE_STR, false);
                        Item primary = getPrimary();
                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.DOT_TYPE_STR)) {
                                EncryptionDetail inheritanceCheckOnSave = new EncryptionDetail(EncryptionDetail.Type.InheritanceCheckOnSave);
                                primary.primaryPropertyEncryption.put(DefaultFrameWriter.DOT_TYPE_STR, inheritanceCheckOnSave);
                        }
                }
        }

        public DotType getDotType() {
                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.DOT_TYPE_STR)) {
                        return this.getPrimary().getDotType();
                } else {
                        return _type;
                }
        }

        
        public void setFilled(boolean filled) {
                invalidateAll();
                _filled = filled;
                invalidateAll();
                
                if (isSurrogate()) {
                        surrogatePropertyInheritance.put(DefaultFrameWriter.FILLED_STR, false);
                        Item primary = getPrimary();
                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.DOT_TYPE_STR)) {
                                EncryptionDetail inheritanceCheckOnSave = new EncryptionDetail(EncryptionDetail.Type.InheritanceCheckOnSave);
                                primary.primaryPropertyEncryption.put(DefaultFrameWriter.FILLED_STR, inheritanceCheckOnSave);
                        }
                }
        }

        public boolean getFilled() {
                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.FILLED_STR)) {
                        return this.getPrimary().getFilled();
                } else {
                        return _filled;
                }
        }

        /**
         * Sets the angle of colour change for gradient colour fills.
         * 
         * @param gradientAngle The new angle of colour change.
         */
        public void setGradientAngle(double gradientAngle) {
                _gradientAngle = gradientAngle;

                for (Line line : _lines) {
                        Item other = line.getOppositeEnd(this);
                        if (other.getGradientAngle() != gradientAngle) other.setGradientAngle(gradientAngle);
                }

                invalidateCommonTrait(ItemAppearence.GradientColor);
                invalidateFill();
                
                if (isSurrogate()) {
                        surrogatePropertyInheritance.put(DefaultFrameWriter.GRADIENT_ANGLE_STR, false);
                        Item primary = getPrimary();
                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.DOT_TYPE_STR)) {
                                EncryptionDetail inheritanceCheckOnSave = new EncryptionDetail(EncryptionDetail.Type.InheritanceCheckOnSave);
                                primary.primaryPropertyEncryption.put(DefaultFrameWriter.GRADIENT_ANGLE_STR, inheritanceCheckOnSave);
                        }
                }
        }

        /**
         * Gets the angle of colour change for gradient fills.
         * 
         * @return The angle of colour change.
         */
        public double getGradientAngle() {
                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.GRADIENT_ANGLE_STR)) {
                        return this.getPrimary().getGradientAngle();
                } else {
                        return _gradientAngle;
                }
        }

        /**
         * Gets the gravity for this item. Gravity is the distance from the item at which mouse interaction
         * applies to the item (like a small buffer zone so you don't need to click exactly on the item).
         * 
         * @return The gravity distance for this item.
         */
        public int getGravity()
        {
                if (isVectorItem()) return 2;
                
                return UserSettings.Gravity.get();
        }

        /**
         * Whether or not line highlights should be shown.
         * TODO: Not really an item method is it? Goes straight to user settings. Refactor. cts16
         * 
         * @return <code>true</code> if line highlighting should be shown, <code>false</code> otherwise.
         */
        public static boolean shouldShowLineHighlight()
        {
                return UserSettings.LineHighlight.get();
        }

        /**
         * Sets the highlight mode for this item.
         * 
         * @param mode The new highlight mode.
         */
        public void setHighlightMode(HighlightMode mode)
        {
                if (hasPermission(UserAppliedPermission.followLinks) || getEditTarget().hasPermission(UserAppliedPermission.followLinks)) {
                        if (_highlightMode != mode) {
                                _highlightMode = mode;
                                this.invalidateCommonTrait(ItemAppearence.HighlightModeChanged);
                        }
                }
        }
        
        public void setOverlayPermission(UserAppliedPermission overlayPermission)
        {
                _overlayPermission = overlayPermission;
        }

        public void setPermission(PermissionTriple permissionPair) {
                List<String> groupMembers = getParent() != null ? getParent().getGroupMembers() : new ArrayList<String>();
                _permissionTriple = permissionPair;
                if (_permissionTriple.getPermission(_owner, groupMembers) == UserAppliedPermission.denied) {
                        this.getParent().moveItemToBodyHiddenDueToPermission(this);
                }
                
                if (isSurrogate()) {
                        surrogatePropertyInheritance.put(DefaultFrameWriter.PERMISSION_STR, false);
                        Item primary = getPrimary();
                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.DOT_TYPE_STR)) {
                                EncryptionDetail inheritanceCheckOnSave = new EncryptionDetail(EncryptionDetail.Type.InheritanceCheckOnSave);
                                primary.primaryPropertyEncryption.put(DefaultFrameWriter.PERMISSION_STR, inheritanceCheckOnSave);
                        }
                }
        }
        
        public PermissionTriple getPermission() {
                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.PERMISSION_STR)) {
                        return this.getPrimary().getPermission();
                } else {
                        return _permissionTriple;
                }
        }

        public UserAppliedPermission getUserAppliedPermission() {
                List<String> groupMembers = getParent() != null ? getParent().getGroupMembers() : new ArrayList<String>();
                String owner = _owner != null ? _owner : _parent != null ? _parent.getOwner() : null;
                if(_permissionTriple != null) return _permissionTriple.getPermission(owner, groupMembers);
                if(_overlayPermission != null) return _overlayPermission;
                if(_parent != null) return _parent.getUserAppliedPermission();
                return UserAppliedPermission.full;
        }
        
        public boolean hasPermission(UserAppliedPermission permission) {
                return getUserAppliedPermission().ordinal() >= permission.ordinal();
        }

        protected Item() {
                _creationDate = Formatter.getLongDateTime();
        }

        /**
         * Adds an action to this Item.
         * 
         * @param action
         *            The name of the action to add to this Item.
         */
        public void addAction(String action)
        {
                if (action == null || action.equals("")) return;

                if (_actions == null) {
                        _actions = new LinkedList<String>();
                }
                
                _actions.add(action);
                
                if (_actions.size() == 1) {
                        invalidateBounds();
                        invalidateCommonTrait(ItemAppearence.LinkChanged);
                }
        }

        public void addAllConnected(Collection<Item> connected)
        {
                if (!connected.contains(this)) connected.add(this);

                for (Item item : getConnected()) {
                        if (!connected.contains(item)) {
                                item.addAllConnected(connected);
                        }
                }
        }

        /**
         * Adds the given Constraint to this Dot
         * 
         * @param c
         *            The Constraint to set this Dot as a member of.
         */
        public void addConstraint(Constraint c)
        {
                // do not add duplicate constraint
                if (_constraints.contains(c))
                        return;

                _constraints.add(c);
        }

        /**
         * Adds a given line to the list of lines that this Point is an end for.
         * 
         * @param line
         *            The Line that this Point is an end of.
         */
        public void addLine(Line line)
        {
                if (_lines.contains(line)) {
                        return;
                }

                _lines.add(line);
        }

        /**
         * Items are sorted by their Y coordinate on the screen.
         * 
         * @param i
         *            The Item to compare this Item to
         * @return a negative integer, zero, or a positive integer as this object is
         *         less than, equal to, or greater than the specified object.
         */
        public int compareTo(Item i)
        {
                return getY() - i.getY();
        }

        /**
         * Every Item has an area around it defined by a Shape (typically a
         * rectangle), this method returns true if the given x,y pair lies within
         * the area and false otherwise.
         * 
         * @param p
         *            The coordinate to check
         * @return True if the Shape around this Item contains the given x,y pair,
         *         false otherwise.
         */
        public boolean contains(Point p)
        {
                return getBounds().contains(p);
        }

        /**
         * Returns a deep copy of this Item, note: it is up to the receiver to
         * change the Item ID etc as necessary.
         * 
         * @return A deep copy of this Item.
         */
        public abstract Item copy();

        public void delete()
        {
                _deleted = true;
        }

        @Override
        public boolean equals(Object o)
        {
                if (o == null)
                        return false;
                if (getClass().equals(o.getClass())) {
                        Item i = (Item) o;
                        return i.getID() == getID()
                                        && ((i.getParent() == _parent) || (i.getParent() != null && i
                                                        .getParent().equals(_parent)));
                } else
                        return false;
        }

        /**
         * Returns a list of any action code that is currently associated with this
         * Item
         * 
         * @return A List of action code associated with this Item, or null if none
         *         has been assigned.
         */
        public List<String> getAction() {
                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.ACTION_STR)) {
                        return this.getPrimary().getAction();
                } else {
                        return _actions;
                }
        }

        public List<String> getData() {
                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.DATA_STR)) {
                        return this.getPrimary().getData();
                } else {
                        return  _data.getData();
                }
        }

        public List<String> getActionCursorEnter() {
                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.ACTION_CURSOR_ENTER_STR)) {
                        return this.getPrimary().getActionCursorEnter();
                } else {
                        return  _actionCursorEnter;
                }
        }

        public List<String> getActionCursorLeave() {
                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.ACTION_CURSOR_LEAVE_STR)) {
                        return this.getPrimary().getActionCursorLeave();
                } else {
                        return  _actionCursorLeave;
                }
        }

        public List<String> getActionEnterFrame() {
                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.ACTION_ENTER_FRAME_STR)) {
                        return this.getPrimary().getActionEnterFrame();
                } else {
                        return  _actionEnterFrame;
                }
        }

        public List<String> getActionLeaveFrame() {
                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.ACTION_LEAVE_FRAME_STR)) {
                        return this.getPrimary().getActionLeaveFrame();
                } else {
                        return  _actionLeaveFrame;
                }
        }

        public boolean getActionMark() {
                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.ACTION_MARK_STR)) {
                        return this.getPrimary().getActionMark();
                } else {
                        return  _actionMark;
                }
        }

        /**
         * Gets all the items connected to this item. Uses a recursive approach to
         * search connected points.
         * 
         * @return
         */
        public Collection<Item> getAllConnected()
        {
                Collection<Item> list = new LinkedHashSet<Item>();
                addAllConnected(list);
                return list;
        }

/*      public Area getArea() {
                return new Area(getPolygon());
        }*/

        public String getArrow() {
                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.ARROW_STR)) {
                        return this.getPrimary().getArrow();
                } else {
                        if (!hasVisibleArrow())
                                return null;

                        String ratio = "" + getArrowheadRatio();
                        if (ratio.length() - ratio.indexOf(".") > 2)
                                ratio = ratio.substring(0, ratio.indexOf(".") + 3);

                        return getArrowheadLength() + " " + ratio + " " + getArrowheadNibPerc();
                }
        }

        public PolygonBounds getArrowhead()
        {
                return _arrowhead;
        }

        public float getArrowheadLength()
        {
                return _arrowheadLength;
        }

        public double getArrowheadRatio()
        {
                return _arrowheadRatio;
        }

        public double getArrowheadNibPerc()
        {
                return _arrowheadNibPerc;
        }
        
        public Colour getBackgroundColor() {
                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.BACKGROUND_COLOR_STR)) {
                        return this.getPrimary().getBackgroundColor();
                } else {
                        return  _backgroundColour;
                }
        }

        public Colour getBorderColor() {
                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.BORDER_COLOR_STR)) {
                        return this.getPrimary().getBorderColor();
                } else {
                        return  _colorBorder;
                }
        }

        /**
         * Returns the Color being used to shade the bottom half of this Item's
         * border. This can be NULL if no Color is being used
         * 
         * @return The Color displayed on the bottom\right half of this Item's
         *         border.
         */
        public Colour getBottomShadowColor()
        {
                return _colorBottomShadow;
        }

        /**
         * Returns the height (in pixels) of this Item's surrounding area.
         * 
         * @return The height (in pixels) of this Item's surrounding area as
         *         returned by getArea().
         */
        public int getBoundsHeight()
        {
                return AxisAlignedBoxBounds.getEnclosing(getBounds()).getHeight();
        }

        /**
         * Returns the width (in pixels) of this Item's surrounding area.
         * 
         * @return The width (in pixels) of this Item's surrounding area as returned
         *         by getArea().
         */
        public int getBoundsWidth()
        {
                return AxisAlignedBoxBounds.getEnclosing(getBounds()).getWidth();
        }

        // TODO: Remove magic constants. cts16
        public EllipticalBounds getLinkBounds()
        {
                if (_linkCircle == null) {
                        _linkCircle = new EllipticalBounds(new Point(6, 3), 7);
                }

                return _linkCircle;
        }

        protected PolygonBounds getCircleCross()
        {

                if (_linkCircleCross == null) {
                        _linkCircleCross = new PolygonBounds();

                        EllipticalBounds poly = getLinkBounds();
                        int x1 = poly.getMinX();
                        int x2 = poly.getMaxX();
                        int y1 = poly.getMinY();
                        int y2 = poly.getMaxY();
                        int midX = (x2 + x1) / 2;
                        int midY = (y2 + y1) / 2;

                        _linkCircleCross.addPoint(new Point(x1, y1));
                        _linkCircleCross.addPoint(new Point(x2, y2));
                        _linkCircleCross.addPoint(new Point(midX, midY));
                        _linkCircleCross.addPoint(new Point(x1, y2));
                        _linkCircleCross.addPoint(new Point(x2, y1));
                        _linkCircleCross.addPoint(new Point(midX, midY));
                }

                return _linkCircleCross;
        }

        public Colour getColor() {
                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.COLOR_STR)) {
                        return this.getPrimary().getColor();
                } else {
                        return  _foregroundColour;
                }
        }

        public Collection<Item> getConnected()
        {
                List<Item> conn = new LinkedList<Item>();
                conn.add(this);
                conn.addAll(getEnclosures());
                conn.addAll(getLines());
                return conn;
        }

        public String getConstraintIDs() {
                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.CONSTRAINT_IDS_STR)) {
                        return this.getPrimary().getConstraintIDs();
                } else {
                        if (_constraints == null || _constraints.size() == 0)
                                return null;

                        String cons = "";

                        for (Constraint c : _constraints)
                                cons += c.getID() + " ";

                        return cons.trim();
                }
        }

        /*
         * public void setLinkValid(boolean val) { _isValidLink = val; }
         */

        /**
         * Returns a List of any Constraints that this Dot is a memeber of.
         * 
         * @return a List of Constraints that this Dot is a member of.
         */
        public List<Constraint> getConstraints()
        {
                return _constraints;
        }

        public String getTag()
        {
                if (_tag != null && _tag.length() > 0)
                        return _tag.toString();
                return null;
        }

        public String getDateCreated() {
                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.DATE_CREATED_STR)) {
                        return this.getPrimary().getDateCreated();
                } else {
                        return  _creationDate;
                }
        }

        public Colour getFillColor() {
                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.FILL_COLOR_STR)) {
                        return this.getPrimary().getFillColor();
                } else {
                        return  _fillColour;
                }
        }

        public String getFillPattern() {
                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.FILL_PATTERN_STR)) {
                        return this.getPrimary().getFillPattern();
                } else {
                        return  _fillPattern;
                }
        }

        public String getFirstAction()
        {
                if (_actions == null || _actions.size() == 0)
                        return null;
                return _actions.get(0);
        }

        /**
         * Gets the value of <code>_highlight</code> for this item.
         * TODO: Appears unused? cts16.
         * 
         * @return The value of <code>_highlight</code>.
         */
        public boolean getHighlight() {
                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.HIGHLIGHT_STR)) {
                        return this.getPrimary().getHighlight();
                } else {
                        return  _highlight;
                }
        }

        public Colour getHighlightColor()
        {
                if (_highlightColour.equals(getPaintColor())) return getAlternateHighlightColor();
                
                return getDefaultHighlightColor();
        }

        /**
         * Returns the ID of this Item, which must be unique for the Frame.
         * 
         * @return The ID of this Item.
         * 
         * TODO: What does it mean to have a negative ID# (as used in TDFC)? cts16
         */
        public int getID() {
                return _id;
        }

        /**
         * Returns the list of IDs of the Lines that this Dot is an end of.
         * 
         * @return The list of Line IDs that this point is part of.
         */
        public String getLineIDs() {
                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.LINE_IDS_STR)) {
                        return this.getPrimary().getLineIDs();
                } else {
                        String lineID = null;

                        if (_lines.size() > 0) {
                                lineID = "" + _lines.get(0).getID();

                                for (int i = 1; i < _lines.size(); i++)
                                        lineID += " " + _lines.get(i).getID();
                        }

                        return lineID;
                }
        }

        public int[] getLinePattern() {
                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.LINE_PATTERN_STR)) {
                        return this.getPrimary().getLinePattern();
                } else {
                        return  _linePattern;
                }
        }

        /**
         * Returns a list of Lines where this Dot is an end.
         * 
         * @return A list of the Lines that this Dot is an end for or null if no
         *         Lines have been added.
         */
        public List<Line> getLines()
        {
                return _lines;
        }

        /**
         * Returns the name of a Frame that this Item links to, or null if this Item
         * has no link.
         * 
         * @return The name of a Frame that this Item links to (if any) or null if
         *         this Item does not link to anything.
         */
        public String getLink() {
                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.LINK_STR)) {
                        return this.getPrimary().getLink();
                } else {
                        return  _link;
                }
        }

        public String getFormula() {
                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.FORMULA_STR)) {
                        return this.getPrimary().getFormula();
                } else {
                        return  _formula;
                }
        }

        public boolean hasFormula()
        {
                return _formula != null;
        }

        public boolean hasAttributeValuePair()
        {
                return _attributeValuePair != null && _attributeValuePair.hasPair();
        }

        public void setFormula(String formula) {
                _formula = formula;
                
                if (isSurrogate()) {
                        surrogatePropertyInheritance.put(DefaultFrameWriter.FORMULA_STR, false);
                        Item primary = getPrimary();
                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.FORMULA_STR)) {
                                EncryptionDetail inheritanceCheckOnSave = new EncryptionDetail(EncryptionDetail.Type.InheritanceCheckOnSave);
                                primary.primaryPropertyEncryption.put(DefaultFrameWriter.FORMULA_STR, inheritanceCheckOnSave);
                        }
                }
        }

        public boolean calculate(String formula)
        {
                setFormula(formula);
                return true;
        }

        public String getLinkFrameset() {
                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.LINK_FRAMESET_STR)) {
                        return this.getPrimary().getLinkFrameset();
                } else {
                        return  _link_frameset;
                }
        }

        public boolean getLinkMark() {
                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.LINK_MARK_STR)) {
                        return this.getPrimary().getLinkMark();
                } else {
                        return  _linkMark;
                }
        }

        public String getLinkTemplate() {
                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.LINK_TEMPLATE_STR)) {
                        return this.getPrimary().getLinkTemplate();
                } else {
                        return  _link_template;
                }
        }

        public Point getOffset()
        {
                return _offset;
        }

        public String getOwner() {
                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.OWNER_STR)) {
                        return this.getPrimary().getOwner();
                } else {
                        return  _owner;
                }
        }

        public Colour getPaintBackgroundColor()
        {
                Colour colorBackground = getBackgroundColor();
                if (colorBackground == null) {
                        if (getParent() != null && getParent().getBackgroundColor() != null)
                                return getParent().getBackgroundColor();

                        return DEFAULT_BACKGROUND;
                }

                return colorBackground;
        }

        /**
         * Returns the foreground Color of this Item.
         * 
         * @return The Color of this item (foreground)
         */
        public final Colour getPaintColor()
        {
                // If color is null then get the paint foregroundColor for the frame the
                // item is on which is a color adjusted to suit the background
                Colour color = getColor();

                if (color == null) {
                        if (getParent() != null)
                                return getParent().getPaintForegroundColor();

                        Frame current = DisplayController.getCurrentFrame();
                        if (current == null) {
                                return DEFAULT_FOREGROUND;
                        }
                        return current.getPaintForegroundColor();
                }

                return color;
        }

        public final Colour getPaintBorderColor()
        {
                // If color is null then get the paint foregroundColor for the frame the
                // item is on which is a color adjusted to suit the background
                Colour color = getBorderColor();

                if (color == null) {
                        if (getParent() != null)
                                return getParent().getPaintForegroundColor();

                        Frame current = DisplayController.getCurrentFrame();
                        if (current == null) {
                                return DEFAULT_FOREGROUND;
                        }
                        return current.getPaintForegroundColor();
                }

                return color;
        }

        protected Colour getPaintHighlightColor()
        {
                Colour highlightColor = getDefaultHighlightColor();
                if (hasVisibleBorder()) {
                        if (getPaintBorderColor().equals(highlightColor)) {
                                highlightColor = getDefaultHighlightColor();
                        }
                } else if (getPaintBackgroundColor().equals(highlightColor)) {
                        highlightColor = getDefaultHighlightColor();
                }
                
                if (getParent() != null && getParent().getPaintBackgroundColor().equals(highlightColor)) {
                        highlightColor = getParent().getPaintForegroundColor();
                }

                if (hasVisibleBorder()) {
                        if (highlightColor.equals(getBorderColor()) && getThickness() == getHighlightThickness()) {
                                highlightColor = highlightColor.clone();
                                highlightColor.setAlpha(Colour.FromComponent255(150));
                        }
                }

                return highlightColor;
        }

        protected Colour getDefaultHighlightColor()
        {
                if (isVectorItem() && !this.contains(EcosystemManager.getInputManager().getCursorPosition())) {
                        return Colour.FromRGB255(255, BRIGHTNESS, BRIGHTNESS);
                }
                return _highlightColour;
        }

        protected Colour getAlternateHighlightColor()
        {
                if (isVectorItem() && !this.contains(EcosystemManager.getInputManager().getCursorPosition())) {
                        return Colour.FromRGB255(BRIGHTNESS, BRIGHTNESS, 255);
                }
                return ALTERNATE_HIGHLIGHT;
        }

        protected int getHighlightThickness()
        {
                if (isVectorItem()) return _vectorHighlightThickness;
                
                return _highlightThickness;
        }

        public final Frame getParent()
        {
                return _parent;
        }

        /** Gets the position of this item. */
        public final Point getPosition() {
                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.POSITION_STR)) {
                        return this.getPrimary().getPosition();
                } else {
                        return new Point(getX(), getY());
                }
        }

        /**
         * Returns the size of this Item. For Text this is the Font size, for Lines
         * and Dots this is the thickness.
         * 
         * @return The size of this Item.
         */
        public float getSize()
        {
                return SIZE_NOT_APPLICABLE;
        }

        /**
         * Returns the Color being used to shade the top half of this Item's border.
         * This can be NULL if no Color is being used
         * 
         * @return The Color displayed on the top\left half of this Item's border.
         */
        public Colour getTopShadowColor()
        {
                return _colorTopShadow;
        }

        public String getTypeAndID() {
                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.TYPE_AND_ID_STR)) {
                        return this.getPrimary().getTypeAndID();
                } else {
                        return "T " + getID();
                }
        }

        public Integer getWidthToSave() {
                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.WIDTH_TO_SAVE_STR)) {
                        return this.getPrimary().getWidthToSave();
                } else {
                        return getWidth();
                }
        }
        
        public Integer getMinWidthToSave() {
                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.MIN_WIDTH_TO_SAVE_STR)) {
                        return this.getPrimary().getMinWidthToSave();
                } else {
                        return getMinWidth();
                }
        }

        public Integer getWidth()
        {
                return null;
        }
        
        public Integer getMinWidth() {
                return null;
        }

        public int getHeight()
        {
                return 0;
        }

        /**
         * Returns the X coordinate of this Item on the screen
         * 
         * @return The X coordinate of this Item on the screen
         */
        public int getX() {
                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.POSITION_STR)) {
                        return this.getPrimary().getX();
                } else {
                        return Math.round(_x);
                }
        }

        /**
         * Returns the Y coordinate of this Item on the screen
         * 
         * @return The Y coordinate of this Item on the screen
         */
        public int getY() {
                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.POSITION_STR)) {
                        return this.getPrimary().getY();
                } else {
                        return Math.round(_y);
                }
        }

        public boolean hasVisibleArrow()
        {
                return isLineEnd() && getArrowheadRatio() != 0 && getArrowheadLength() != 0;
        }

        /**
         * Checks if the given Shape intersects with the Shape around this Item.
         * 
         * @param s
         *            The Shape to check.
         * @return True if the two Shapes overlap, False otherwise.
         */
        public boolean intersects(PolygonBounds otherBounds)
        {
                if (otherBounds == null) return false;
                
                Bounds thisBounds = getBounds();
                
                // Need to do this check for circles
                if (otherBounds.equals(thisBounds)) return true;

                boolean intersects = otherBounds.intersects(thisBounds);
                
                /*if (intersects) {
                        System.err.println("Found intersection between this item (" + this + ") with bounds: " + thisBounds + "...and...");
                        System.err.println("item with bounds: " + otherBounds.toString());
                }*/
                return intersects;

                // Need to check the second equality so that we dont pick up circles
                // inside other circles
                //return !a.isEmpty() && !a.equals(new Area(p));
        }

        /**
         * Note: Pictures always return False, as they should be drawn even when no
         * other annotation Items are.
         * 
         * @return True if this Item is an annotation, False otherwise.
         */
        public boolean isAnnotation()
        {
                return false;
        }

        public boolean isFloating()
        {
                return _floating;
        }

        public boolean isFrameName()
        {
                if (this.getParent() == null || this.getParent().getNameItem() != this)
                        return false;
                return true;
        }

        public boolean isFrameTitle()
        {
                if (this.getParent() == null || this.getParent().getTitleItem() != this)
                        return false;
                return true;
        }

        /**
         * Returns True if this Item is currently highlighted.
         * 
         * @return True if this Item is currently highlighted on the screen, False
         *         otherwise.
         */
        public boolean isHighlighted()
        {
                if (isFloating())
                        return false;
                return _highlightMode != HighlightMode.None;
        }

        /**
         * Tests if the item link is a valid framename, that is, the String must
         * begin with a character, end with a number with 0 or more letters and
         * numbers in between. If there is a dot in the framename all the chars
         * after it must be digits.
         * 
         * @return True if the given framename is proper, false otherwise.
         */
        public boolean isLinkValid()
        {
                if (FrameIO.isPositiveInteger(getLink()))
                        return true;

                if (FrameIO.isValidFrameName(getLink()))
                        return true;
                return false;
        }

        /**
         * Checks if the given point is 'near' to the item. Here 'near' means within a certain distance
         * of the axis-aligned box bounding the item's polygon.
         * 
         * @param x
         *              The x-coordinate of the point to check.
         * 
         * @param y
         *              The y-coordinate of the point to check.
         * 
         * @return
         *              True if the given point is 'near' to the item, false otherwise.
         */
        public boolean isNear(int x, int y)
        {
                AxisAlignedBoxBounds box = ItemUtils.expandRectangle(getBoundingBox(), NEAR_DISTANCE * 2);
                
                return box.contains(x, y);
        }

        public boolean isOldTag()
        {
                if (this instanceof Text)
                        if (((Text) this).getTextList().get(0).toLowerCase().equals("@old"))
                                return true;
                return false;
        }

        /**
         * Merges this Item with the given Item. The merger Item should be left
         * unchanged after this method. The merger may or may not be the same class
         * as this Item, exact behaviour depends on the subclass, No-op is allowed.
         * 
         * @param merger
         *            The Item to merge with
         * @return any Item that should remain on the cursor
         */
        public abstract Item merge(Item merger, int mouseX, int mouseY);

        /**
         * Displays this item directly on the screen. Note: All Items are
         * responsible for their own drawing, buffering, etc.
         * 
         * @param g
         *            The Graphics to draw this Item on.
         */
        public abstract void paint();
        
        public void setTooltips(final List<String> tooltips)
        {
                if (tooltips == null || tooltips.size() == 0) {
                        _tooltip = new Tooltip();
                } else {
                        for (final String content: tooltips) _tooltip.addTooltip(content, this);
                }
        }
        
        public void setTooltip(final String tooltip) {
                if(tooltip != null && tooltip.trim().length() > 0) {
                        _tooltip.addTooltip(tooltip, this);
                }
                
                if (isSurrogate()) {
                        surrogatePropertyInheritance.put(DefaultFrameWriter.TOOLTIP_STR, false);
                        Item primary = getPrimary();
                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.TOOLTIP_STR)) {
                                EncryptionDetail inheritanceCheckOnSave = new EncryptionDetail(EncryptionDetail.Type.InheritanceCheckOnSave);
                                primary.primaryPropertyEncryption.put(DefaultFrameWriter.TOOLTIP_STR, inheritanceCheckOnSave);
                        }
                }
        }
        
        public List<String> getTooltip() {
                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.TOOLTIP_STR)) {
                        return this.getPrimary().getTooltip();
                } else {
                        return _tooltip.asStringList();
                }
        }
        
        public Collection<Text> getTooltipItems()
        {
                return _tooltip.getTooltips();
        }

        public void clearTooltips()
        {
                final Frame frame = this.getParent();
                if(_tooltip != null) {
                        for(final Text tooltip: _tooltip.getTooltips()) frame.removeItem(tooltip);
                }
        }
        
        public void paintTooltip()
        {
                final Bounds bounds = AxisAlignedBoxBounds.getEnclosing(this.getBoundingBox());
                Dimension frameSize = DisplayController.getFramePaintAreaSize();
                
                int x = bounds.getMaxX();
                
                // If the tooltip goes off the right side of the window, move it left so it's completely on
                if(x + _tooltip.getWidth() > frameSize.getWidth()) {
                        x = frameSize.getWidth() - _tooltip.getWidth();
                }
                
                int y = bounds.getMaxY();
                
                if(y + _tooltip.getCollectiveHeight() > frameSize.getHeight()) {
                        y = (bounds.getMinY() + bounds.getMaxY()) / 2 - _tooltip.getCollectiveHeight();
                }
                
                for(final Text tooltip : _tooltip.getTooltips()) {
                        this.getParent().addItem(tooltip);
                        tooltip.setPosition(x, y);
                        tooltip.paint();
                        y += tooltip.getHeight();
                }
        }
        
        public void paintFill() {
                Colour fillColor = getFillColor();
                if (fillColor != null && getEnclosingDots() != null) {
                        Fill fill = getFill();
                        EcosystemManager.getGraphicsManager().drawPolygon(getEnclosedShape(), null, null, 0.0f, fill, null, null);
                }
        }

        protected Fill getFill() {
                Fill fill;
                Colour fillColour = getFillColor();
                if (isFloating()) {
                        // TODO experiment with adding alpha when picking up filled
                        // items... Slows things down quite alot!!
                        // TODO: Does nothing as it stands... cts16
                        fillColour = new Colour(fillColour.getRed(), fillColour.getGreen(),
                                        fillColour.getBlue(), fillColour.getAlpha());
                }
                Colour gradientColor = getGradientColor();
                PolygonBounds poly = getEnclosedShape();
                if (gradientColor != null && poly != null) {
                        /*
                         * It is slow when painting gradients... modify so this is only done
                         * once unless it is resized...
                         */
                        AxisAlignedBoxBounds b = AxisAlignedBoxBounds.getEnclosing(poly);
                        double rads = getGradientAngle();
                        double cos = Math.cos(rads);
                        double sin = Math.sin(rads);

                        Point fromPoint = new Point((int) (b.getMinX() + b.getWidth() * (0.2 * cos + 0.5)), (int) (b.getMinY() + b.getHeight() * (0.2 * sin + 0.5)));
                        Point toPoint = new Point((int) (b.getMinX() + b.getWidth() * (-0.8 * cos + 0.5)), (int) (b.getMinY() + b.getHeight() * (-0.8 * sin + 0.5)));
                        
                        fill = new GradientFill(fillColour, fromPoint, gradientColor, toPoint);
                } else {
                        fill = new Fill(fillColour);
                }
                
                return fill;
        }

        /**
         * This method performs all the actions in an items list. If it contains a
         * link as well the link is used as the source frame for all actions.
         */
        public void performActions() {
                Frame sourceFrame = null;
                Item sourceItem = FreeItems.getItemAttachedToCursor();

                if (sourceItem == null) {
                        sourceItem = this;
                } else {
                        for (Item i : sourceItem.getAllConnected()) {
                                if (i instanceof Text) {
                                        sourceItem = i;
                                        break;
                                }
                        }
                }

                // TODO decide whether to have items or
                // if a link exists make it the source frame for this action
                if (getLink() != null) {
                        sourceFrame = FrameUtils.getFrame(getAbsoluteLink());
                }
                // if no link exists or the link is bad then use the
                // currently displayed frame as the source frame for the
                // action
                if (sourceFrame == null) {
                        // For actions like format they rely on this being set to the
                        // current frame incase the item being activated is on an overlay
                        sourceFrame = DisplayController.getCurrentFrame();
                }

                for (String s : getAction()) {
                        Object returnValue;
                        if (LegacyFeatures.UseLegacyActionArgumentMapping.get()) { 
                                returnValue = Actions.LegacyPerformActionCatchErrors(sourceFrame, sourceItem, s);
                        } else {
                                returnValue = Actions.PerformActionCatchErrors(sourceFrame, sourceItem, s, this);
                        }
                        
                        if (returnValue != null) {
                                FreeItems.getInstance().clear();
                                if (returnValue instanceof Item) {
                                        Misc.attachToCursor(((Item) returnValue).getAllConnected());
                                } else if (returnValue instanceof Collection) {
                                        try {
                                                Misc.attachToCursor((Collection) returnValue);
                                        } catch (Exception e) {
                                                e.printStackTrace();
                                        }
                                } else {
                                        Misc.attachStatsToCursor(returnValue.toString());
                                }
                        }
                }
        }

        /**
         * Removes all constraints that this item has.
         * 
         */
        public void removeAllConstraints() {
                while (_constraints.size() > 0) {
                        Constraint c = _constraints.get(0);
                        c.getEnd().removeConstraint(c);
                        c.getStart().removeConstraint(c);
                }
        }

        /**
         * Clears the list of Lines that this Dot is an end of. Note: This only
         * clears this Dot's list and does not have any affect on the Lines or other
         * Dots.
         */
        public void removeAllLines() {
                for (Line l : _lines) {
                        l.invalidateAll();
                }
                _lines.clear();
        }

        /**
         * Removes the given Constraint from the list of constraints that this Dot
         * is a part of.
         * 
         * @param c
         *            The Constraint that this Dot is no longer a part of.
         */
        public void removeConstraint(Constraint c) {
                _constraints.remove(c);
        }

        /**
         * Removes the given Line from the list of lines that this Dot is an end
         * for.
         * 
         * @param line
         *            The Line that this Dot is no longer an end of.
         */
        public void removeLine(Line line) {
                if (_lines.remove(line))
                        line.invalidateAll();
        }

        public void run() {
                try {
                        
                        List<String> action = this.getAction();
                        if (action != null) {
                                String action_name = action.get(0);
                                if (action_name.equalsIgnoreCase("RunJavascriptFrame")){
                                    // Associate a new Context with this thread
                                org.mozilla.javascript.Context javascript_context = org.mozilla.javascript.Context.enter();
                                try {
                                        Scriptable javascript_scope = javascript_context.initStandardObjects();
                                        Context simple_context = new Context();
                                        
                                        
                                        //Object jsDisplayIO = org.mozilla.javascript.Context.javaToJS(org.expeditee.gui.DisplayIO, javascript_scope);
                                        //ScriptableObject.putProperty(javascript_scope, "displayIO", jsDisplayIO);
                                        
                                        
                                        Object jsSimpleContext = org.mozilla.javascript.Context.javaToJS(simple_context, javascript_scope);
                                        ScriptableObject.putProperty(javascript_scope, "simpleContext", jsSimpleContext);
                                           
                                        Object jsErr = org.mozilla.javascript.Context.javaToJS(System.err, javascript_scope);
                                        ScriptableObject.putProperty(javascript_scope, "err", jsErr);
                                   
                                        Object jsOut = org.mozilla.javascript.Context.javaToJS(System.out, javascript_scope);
                                        ScriptableObject.putProperty(javascript_scope, "out", jsOut);
                                           
                                        Javascript.ProgramStarted();
                                        Javascript.RunFrameAndReportError(this, javascript_context,javascript_scope);
                                        MessageBay.displayMessage(AgentStats.getStats(), GREEN);
                                }
                                finally {
                                        org.mozilla.javascript.Context.exit();
                                }
                                }
                        }
                        else {
                                
                                // assume it is a simple program that is to be run
                                Simple.ProgramStarted();
                                Context simple_context = new Context();
                                Simple.RunFrameAndReportError(this, simple_context);
                                MessageBay.displayMessage(AgentStats.getStats(), GREEN);
                        }
                } catch (ConcurrentModificationException ce) {
                        ce.printStackTrace();
                } catch (IncorrectUseOfStatementException ise) {
                        MessageBay.linkedErrorMessage(ise.getMessage());
                        MessageBay.displayMessage("See SIMPLE doc for ["
                                        + ise.getStatement() + "] statement", ise.getStatement()
                                        + "1", Colour.CYAN.darker(), true, null);
                } catch (Exception e) {
                        MessageBay.linkedErrorMessage(e.getMessage());
                }
                Simple.ProgramFinished();
                // Need to repaint any highlights etc
                DisplayController.requestRefresh(true);
        }

        /**
         * Check if it has a relative link if so make it absolute.
         * 
         */
        public void setAbsoluteLink() {
                String link = getLink();
                if (link == null)
                        return;
                // Check if all the characters are digits and hence it is a relative
                // link
                if (!FrameIO.isPositiveInteger(link))
                        return;

                // Make it an absolute link
                String framesetName;

                if (_parent == null)
                        framesetName = DisplayController.getCurrentFrame().getFramesetName();
                else
                        framesetName = _parent.getFramesetName();

                setLink(framesetName + link);
        }

        /**
         * Sets any action code that should be associated with this Item Each entry
         * in the list is one line of code
         * 
         * @param actions
         *            The lines of code to associate with this Item
         */
        public void setActions(List<String> actions) {
                if (actions == null || actions.size() == 0) {
                        invalidateCommonTrait(ItemAppearence.LinkChanged);
                        _actions = null;
                } else {
                        _actions = new LinkedList<String>(actions);
                }
                
                // Want to resize the highlight box for text items if actions have been added
                invalidateBounds();
                invalidateCommonTrait(ItemAppearence.LinkChanged);
                
                if (isSurrogate()) {
                        surrogatePropertyInheritance.put(DefaultFrameWriter.ACTION_STR, false);
                        Item primary = getPrimary();
                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.ACTION_STR)) {
                                EncryptionDetail inheritanceCheckOnSave = new EncryptionDetail(EncryptionDetail.Type.InheritanceCheckOnSave);
                                primary.primaryPropertyEncryption.put(DefaultFrameWriter.ACTION_STR, inheritanceCheckOnSave);
                        }
                }
        }

        public void setData(List<String> data) {
                _data.setData(data);
        }

        public void setData(String data) {
                _data.setData(data);
        }

        public void addToData(String dataItem) {
                _data.addToData(dataItem);
                
                if (isSurrogate()) {
                        surrogatePropertyInheritance.put(DefaultFrameWriter.DATA_STR, false);
                        Item primary = getPrimary();
                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.DATA_STR)) {
                                EncryptionDetail inheritanceCheckOnSave = new EncryptionDetail(EncryptionDetail.Type.InheritanceCheckOnSave);
                                primary.primaryPropertyEncryption.put(DefaultFrameWriter.DATA_STR, inheritanceCheckOnSave);
                        }
                }
        }
        
        public boolean hasData(String dataItem) {
                return _data.hasData(dataItem);
        }

        public void setActionCursorEnter(List<String> enter) {
                _actionCursorEnter = enter;
                
                if (isSurrogate()) {
                        surrogatePropertyInheritance.put(DefaultFrameWriter.ACTION_CURSOR_ENTER_STR, false);
                        Item primary = getPrimary();
                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.ACTION_CURSOR_ENTER_STR)) {
                                EncryptionDetail inheritanceCheckOnSave = new EncryptionDetail(EncryptionDetail.Type.InheritanceCheckOnSave);
                                primary.primaryPropertyEncryption.put(DefaultFrameWriter.ACTION_CURSOR_ENTER_STR, inheritanceCheckOnSave);
                        }
                }
        }

        public void setActionCursorLeave(List<String> leave) {
                _actionCursorLeave = leave;
                
                if (isSurrogate()) {
                        surrogatePropertyInheritance.put(DefaultFrameWriter.ACTION_CURSOR_LEAVE_STR, false);
                        Item primary = getPrimary();
                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.ACTION_CURSOR_LEAVE_STR)) {
                                EncryptionDetail inheritanceCheckOnSave = new EncryptionDetail(EncryptionDetail.Type.InheritanceCheckOnSave);
                                primary.primaryPropertyEncryption.put(DefaultFrameWriter.ACTION_CURSOR_LEAVE_STR, inheritanceCheckOnSave);
                        }
                }
        }

        public void setActionEnterFrame(List<String> enter) {
                _actionEnterFrame = enter;
                
                if (isSurrogate()) {
                        surrogatePropertyInheritance.put(DefaultFrameWriter.ACTION_ENTER_FRAME_STR, false);
                        Item primary = getPrimary();
                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.ACTION_ENTER_FRAME_STR)) {
                                EncryptionDetail inheritanceCheckOnSave = new EncryptionDetail(EncryptionDetail.Type.InheritanceCheckOnSave);
                                primary.primaryPropertyEncryption.put(DefaultFrameWriter.ACTION_ENTER_FRAME_STR, inheritanceCheckOnSave);
                        }
                }
        }

        public void setActionLeaveFrame(List<String> leave) {
                _actionLeaveFrame = leave;
                
                if (isSurrogate()) {
                        surrogatePropertyInheritance.put(DefaultFrameWriter.ACTION_LEAVE_FRAME_STR, false);
                        Item primary = getPrimary();
                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.ACTION_LEAVE_FRAME_STR)) {
                                EncryptionDetail inheritanceCheckOnSave = new EncryptionDetail(EncryptionDetail.Type.InheritanceCheckOnSave);
                                primary.primaryPropertyEncryption.put(DefaultFrameWriter.ACTION_LEAVE_FRAME_STR, inheritanceCheckOnSave);
                        }
                }
        }

        public void setActionMark(boolean val) {
                if (!val) invalidateCommonTrait(ItemAppearence.LinkChanged);
                invalidateBounds();
                _actionMark = val;
                if (val) invalidateCommonTrait(ItemAppearence.LinkChanged);
                
                if (isSurrogate()) {
                        surrogatePropertyInheritance.put(DefaultFrameWriter.ACTION_MARK_STR, false);
                        Item primary = getPrimary();
                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.ACTION_MARK_STR)) {
                                EncryptionDetail inheritanceCheckOnSave = new EncryptionDetail(EncryptionDetail.Type.InheritanceCheckOnSave);
                                primary.primaryPropertyEncryption.put(DefaultFrameWriter.ACTION_MARK_STR, inheritanceCheckOnSave);
                        }
                }
        }

        /**
         * Sets whether this Item is an Annotation.
         * 
         * @param val
         *            True if this Item is an Annotation, False otherwise.
         */
        public abstract void setAnnotation(boolean val);

        /**
         * Used to set this Line as an Arrow. If length and ratio are 0, no arrow is
         * shown.
         * 
         * @param length
         *            The how far down the shaft of the line the arrowhead should
         *            come.
         * @param ratio
         *            The ratio of the arrow's length to its width.
         */
        public void setArrow(float length, double ratio, double nib_perc) {
                _arrowheadLength = length;
                _arrowheadRatio = ratio;
                _arrowheadNibPerc = nib_perc;
                updateArrowPolygon();
                
                if (isSurrogate()) {
                        surrogatePropertyInheritance.put(DefaultFrameWriter.ARROW_STR, false);
                        Item primary = getPrimary();
                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.ARROW_STR)) {
                                EncryptionDetail inheritanceCheckOnSave = new EncryptionDetail(EncryptionDetail.Type.InheritanceCheckOnSave);
                                primary.primaryPropertyEncryption.put(DefaultFrameWriter.ARROW_STR, inheritanceCheckOnSave);
                        }
                }
        }

        public void setArrow(float length, double ratio) {
                setArrow(length,ratio,DEFAULT_ARROWHEAD_NIB_PERC);
        }
        
        public void setArrowhead(PolygonBounds arrow) {
                _arrowhead = arrow;
        }

        public void setArrowheadLength(float length) {
                _arrowheadLength = length;
                updateArrowPolygon();
        }

        public void setArrowheadRatio(double ratio) {
                _arrowheadRatio = ratio;
                updateArrowPolygon();
        }
        
        public void setArrowheadNibPerc(double perc) {
                _arrowheadNibPerc = perc;
                updateArrowPolygon();
        }

        public void setBackgroundColor(Colour c) {
                if (c != _backgroundColour) {
                        _backgroundColour = c;
                        invalidateCommonTrait(ItemAppearence.BackgroundColorChanged);
                }
                
                if (isSurrogate()) {
                        surrogatePropertyInheritance.put(DefaultFrameWriter.BACKGROUND_COLOR_STR, false);
                        Item primary = getPrimary();
                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.BACKGROUND_COLOR_STR)) {
                                EncryptionDetail inheritanceCheckOnSave = new EncryptionDetail(EncryptionDetail.Type.InheritanceCheckOnSave);
                                primary.primaryPropertyEncryption.put(DefaultFrameWriter.BACKGROUND_COLOR_STR, inheritanceCheckOnSave);
                        }
                }
        }

        public void setBorderColor(Colour c) {
                if (c != _colorBorder) {
                        _colorBorder = c;
                        invalidateCommonTrait(ItemAppearence.BorderColorChanged);
                }
                
                if (isSurrogate()) {
                        surrogatePropertyInheritance.put(DefaultFrameWriter.BORDER_COLOR_STR, false);
                        Item primary = getPrimary();
                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.BORDER_COLOR_STR)) {
                                EncryptionDetail inheritanceCheckOnSave = new EncryptionDetail(EncryptionDetail.Type.InheritanceCheckOnSave);
                                primary.primaryPropertyEncryption.put(DefaultFrameWriter.BORDER_COLOR_STR, inheritanceCheckOnSave);
                        }
                }
        }

        /**
         * Sets the Color to use on the bottom and right sections of this Item's
         * border. If top is NULL, then the Item's background Color will be used.
         * 
         * @param top
         *            The Color to display in the bottom and right sections of this
         *            Item's border.
         */
        public void setBottomShadowColor(Colour bottom) {
                _colorBottomShadow = bottom;
        }

        /**
         * Sets the foreground Color of this Item to the given Color.
         * 
         * @param c
         */
        public void setColor(Colour c) {
                if (c != _foregroundColour) {
                        _foregroundColour = c;
                        invalidateCommonTrait(ItemAppearence.ForegroundColorChanged);
                        if (hasVector()) {
                                // TODO make this more efficient so it only repaints the items
                                // for this vector
                                StandardGestureActions.Refresh();
                        }
                }
        }

        public void setConstraintIDs(String IDs) {
                if (isSurrogate()) {
                        surrogatePropertyInheritance.put(DefaultFrameWriter.CONSTRAINT_IDS_STR, false);
                        Item primary = getPrimary();
                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.CONSTRAINT_IDS_STR)) {
                                EncryptionDetail inheritanceCheckOnSave = new EncryptionDetail(EncryptionDetail.Type.InheritanceCheckOnSave);
                                primary.primaryPropertyEncryption.put(DefaultFrameWriter.CONSTRAINT_IDS_STR, inheritanceCheckOnSave);
                        }
                }
        }

        public void setConstraints(List<Constraint> constraints) {
                _constraints = constraints;
        }

        public void setTag(String newData) {
                if (newData != null)
                        _tag = new StringBuffer(newData);
                else
                        _tag = null;
        }

        /**
         * Sets the created date of this Frame to the given String.
         * 
         * @param date
         *            The date to use for this Frame.
         */
        public void setDateCreated(String date) {
                _creationDate = date;
                
                if (isSurrogate()) {
                        surrogatePropertyInheritance.put(DefaultFrameWriter.DATE_CREATED_STR, false);
                        Item primary = getPrimary();
                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.DATE_CREATED_STR)) {
                                EncryptionDetail inheritanceCheckOnSave = new EncryptionDetail(EncryptionDetail.Type.InheritanceCheckOnSave);
                                primary.primaryPropertyEncryption.put(DefaultFrameWriter.DATE_CREATED_STR, inheritanceCheckOnSave);
                        }
                }
        }

        public void setFillColor(Colour c) {

                _fillColour = c;

                for (Line line : _lines) {
                        Item other = line.getOppositeEnd(this);
                        if (other.getFillColor() != c) {
                                other.setFillColor(c);
                        }
                }

                invalidateCommonTrait(ItemAppearence.FillColor);
                invalidateFill();
                
                if (isSurrogate()) {
                        surrogatePropertyInheritance.put(DefaultFrameWriter.FILL_COLOR_STR, false);
                        Item primary = getPrimary();
                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.FILL_COLOR_STR)) {
                                EncryptionDetail inheritanceCheckOnSave = new EncryptionDetail(EncryptionDetail.Type.InheritanceCheckOnSave);
                                primary.primaryPropertyEncryption.put(DefaultFrameWriter.FILL_COLOR_STR, inheritanceCheckOnSave);
                        }
                }
        }

        public void setGradientColor(Colour c) {
                _gradientColour = c;

                for (Line line : _lines) {
                        Item other = line.getOppositeEnd(this);
                        if (other.getGradientColor() != c)
                                other.setGradientColor(c);
                }

                invalidateCommonTrait(ItemAppearence.GradientColor);
                invalidateFill();
                
                if (isSurrogate()) {
                        surrogatePropertyInheritance.put(DefaultFrameWriter.GRADIENT_COLOR_STR, false);
                        Item primary = getPrimary();
                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.GRADIENT_COLOR_STR)) {
                                EncryptionDetail inheritanceCheckOnSave = new EncryptionDetail(EncryptionDetail.Type.InheritanceCheckOnSave);
                                primary.primaryPropertyEncryption.put(DefaultFrameWriter.GRADIENT_COLOR_STR, inheritanceCheckOnSave);
                        }
                }
        }

        public Colour getGradientColor() {
                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.GRADIENT_COLOR_STR)) {
                        return this.getPrimary().getGradientColor();
                } else {
                        return _gradientColour;
                }
        }

        public void setFillPattern(String patternLink) {
                _fillPattern = patternLink;
                invalidateCommonTrait(ItemAppearence.FillPattern);
                invalidateFill();
                
                if (isSurrogate()) {
                        surrogatePropertyInheritance.put(DefaultFrameWriter.FILL_PATTERN_STR, false);
                        Item primary = getPrimary();
                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.FILL_PATTERN_STR)) {
                                EncryptionDetail inheritanceCheckOnSave = new EncryptionDetail(EncryptionDetail.Type.InheritanceCheckOnSave);
                                primary.primaryPropertyEncryption.put(DefaultFrameWriter.FILL_PATTERN_STR, inheritanceCheckOnSave);
                        }
                }
        }

        public void setFloating(boolean val) {
                _floating = val;
        }

        /**
         * Sets the value <code>_highlight</code> for this item.
         * TODO: Appears unused? cts16
         * 
         * @param val The new value for <code>_highlight</code>.
         */
        public void setHighlight(boolean val) {
                _highlight = val;
                
                if (isSurrogate()) {
                        surrogatePropertyInheritance.put(DefaultFrameWriter.HIGHLIGHT_STR, false);
                        Item primary = getPrimary();
                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.HIGHLIGHT_STR)) {
                                EncryptionDetail inheritanceCheckOnSave = new EncryptionDetail(EncryptionDetail.Type.InheritanceCheckOnSave);
                                primary.primaryPropertyEncryption.put(DefaultFrameWriter.HIGHLIGHT_STR, inheritanceCheckOnSave);
                        }
                }
        }

        /**
         * Sets the ID of this Item to the given Integer. Note: Items with ID's < 0
         * are not saved
         * 
         * @param newID
         *            The new ID to assign this Item.
         */
        public void setID(int newID) {
                _id = newID;
                
                if (isSurrogate()) {
                        surrogatePropertyInheritance.put(DefaultFrameWriter.TYPE_AND_ID_STR, false);
                        Item primary = getPrimary();
                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.TYPE_AND_ID_STR)) {
                                EncryptionDetail inheritanceCheckOnSave = new EncryptionDetail(EncryptionDetail.Type.InheritanceCheckOnSave);
                                primary.primaryPropertyEncryption.put(DefaultFrameWriter.TYPE_AND_ID_STR, inheritanceCheckOnSave);
                        }
                }
        }
        
        /**
         * Function called when a user attempts to set the ID of a Item.  Simply provides
         * feedback to the user telling them that they are not allowed to do this.  This
         * function is provided so that users are able to get the ID of a item when 
         * extracting properties.  See {@link org.expeditee.gui.AttributeUtils}.
         * 
         * @param newID The requested new ID that will be ignored.
         */
        public void setIDFail(int newID) {
                MessageBay.displayMessage("A user cannot change the ID of an item.");
        }

        /**
         * Sets the list of lines that this point is part of (may be set to null).
         * 
         * @param lineID
         *            A String of line ID numbers separated by spaces.
         */
        public void setLineIDs(String lineID) {
                if (isSurrogate()) {
                        surrogatePropertyInheritance.put(DefaultFrameWriter.LINE_IDS_STR, false);
                        Item primary = getPrimary();
                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.LINE_IDS_STR)) {
                                EncryptionDetail inheritanceCheckOnSave = new EncryptionDetail(EncryptionDetail.Type.InheritanceCheckOnSave);
                                primary.primaryPropertyEncryption.put(DefaultFrameWriter.LINE_IDS_STR, inheritanceCheckOnSave);
                        }
                }
        }

        public void setLinePattern(int[] pattern) {
                _linePattern = pattern;

                for (Line line : getLines())
                        line.setLinePattern(pattern);
                
                if (isSurrogate()) {
                        surrogatePropertyInheritance.put(DefaultFrameWriter.LINE_PATTERN_STR, false);
                        Item primary = getPrimary();
                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.LINE_PATTERN_STR)) {
                                EncryptionDetail inheritanceCheckOnSave = new EncryptionDetail(EncryptionDetail.Type.InheritanceCheckOnSave);
                                primary.primaryPropertyEncryption.put(DefaultFrameWriter.LINE_PATTERN_STR, inheritanceCheckOnSave);
                        }
                }
        }

        public void setLines(List<Line> lines) {
                _lines = lines;

                for (Line line : lines)
                        line.setLinePattern(getLinePattern());

        }

        /**
         * Links this item to the given Frame, this may be set to null to remove a
         * link.
         * 
         * @param frameName
         *            The name of the Frame to link this item to.
         */
        public void setLink(String frameName) {
                if (frameName == null) invalidateCommonTrait(ItemAppearence.LinkChanged);

                // If a link is being removed or set then need to reset _bounds so the
                // highlighting is drawn with the correct width
                if (frameName == null || getLink() == null) invalidateBounds();

                if (FrameIO.isValidLink(frameName)) {
                        _link = frameName;
                } else {
                        MessageBay.errorMessage("[" + frameName + "] is not a valid frame name");
                }
                // TODO make this throw exceptions etc...

                invalidateCommonTrait(ItemAppearence.LinkChanged);
                
                if (isSurrogate()) {
                        surrogatePropertyInheritance.put(DefaultFrameWriter.LINK_STR, false);
                        Item primary = getPrimary();
                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.LINK_STR)) {
                                EncryptionDetail inheritanceCheckOnSave = new EncryptionDetail(EncryptionDetail.Type.InheritanceCheckOnSave);
                                primary.primaryPropertyEncryption.put(DefaultFrameWriter.LINK_STR, inheritanceCheckOnSave);
                        }
                }
        }
        
        public void setLinkHistory(boolean value) {
                _linkHistory = value;
                
                if (isSurrogate()) {
                        surrogatePropertyInheritance.put(DefaultFrameWriter.LINK_HISTORY_STR, false);
                        Item primary = getPrimary();
                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.LINK_HISTORY_STR)) {
                                EncryptionDetail inheritanceCheckOnSave = new EncryptionDetail(EncryptionDetail.Type.InheritanceCheckOnSave);
                                primary.primaryPropertyEncryption.put(DefaultFrameWriter.LINK_HISTORY_STR, inheritanceCheckOnSave);
                        }
                }
        }
        
        public boolean getLinkHistory() {
                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.LINK_HISTORY_STR)) {
                        return this.getPrimary().getLinkHistory();
                } else {
                        return _linkHistory;
                }
        }

        public void setLinkFrameset(String frameset)
        {
                if (frameset == null || FrameIO.isValidFramesetName(frameset)) {
                        _link_frameset = frameset;
                } else {
                        MessageBay.errorMessage("[" + frameset + "] is not a valid frameset name");
                }
                // TODO make this throw exceptions etc...
                
                if (isSurrogate()) {
                        surrogatePropertyInheritance.put(DefaultFrameWriter.LINK_FRAMESET_STR, false);
                        Item primary = getPrimary();
                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.LINK_FRAMESET_STR)) {
                                EncryptionDetail inheritanceCheckOnSave = new EncryptionDetail(EncryptionDetail.Type.InheritanceCheckOnSave);
                                primary.primaryPropertyEncryption.put(DefaultFrameWriter.LINK_FRAMESET_STR, inheritanceCheckOnSave);
                        }
                }
        }

        public void setLinkMark(boolean val) {
                if (!val) invalidateCommonTrait(ItemAppearence.LinkChanged);
                invalidateBounds();
                _linkMark = val;
                if (val) invalidateCommonTrait(ItemAppearence.LinkChanged);
                
                if (isSurrogate()) {
                        surrogatePropertyInheritance.put(DefaultFrameWriter.LINK_MARK_STR, false);
                        Item primary = getPrimary();
                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.LINK_MARK_STR)) {
                                EncryptionDetail inheritanceCheckOnSave = new EncryptionDetail(EncryptionDetail.Type.InheritanceCheckOnSave);
                                primary.primaryPropertyEncryption.put(DefaultFrameWriter.LINK_MARK_STR, inheritanceCheckOnSave);
                        }
                }
        }

        public void setLinkTemplate(String template) {
                if (FrameIO.isValidLink(template)) {
                        _link_template = template;
                } else {
                        MessageBay.errorMessage("[" + template + "] is not a valid frame name");
                }
                // TODO make this throw exceptions etc...
                
                if (isSurrogate()) {
                        surrogatePropertyInheritance.put(DefaultFrameWriter.LINK_TEMPLATE_STR, false);
                        Item primary = getPrimary();
                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.LINK_TEMPLATE_STR)) {
                                EncryptionDetail inheritanceCheckOnSave = new EncryptionDetail(EncryptionDetail.Type.InheritanceCheckOnSave);
                                primary.primaryPropertyEncryption.put(DefaultFrameWriter.LINK_TEMPLATE_STR, inheritanceCheckOnSave);
                        }
                }
        }

        // /**
        // * Sets the maximum coordinates on the screen that this item may occupy.
        // * This is used by Text items to compute word-wrapping lengths.
        // *
        // * @param d
        // * The Maximum size of the Frame containing this Item.
        // */
        // public void setMaxWidth(int width) {
        // if (width > 0) {
        // _maxWidth = width;
        // updatePolygon();
        // }
        // }

        public void setOffset(int x, int y) {
                _offset.set(x, y);
        }

        public void setOffset(Point p) {
                _offset.set(p);
        }

        public void setOwner(String own) {
                _owner = own;
                
                if (isSurrogate()) {
                        surrogatePropertyInheritance.put(DefaultFrameWriter.OWNER_STR, false);
                        Item primary = getPrimary();
                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.OWNER_STR)) {
                                EncryptionDetail inheritanceCheckOnSave = new EncryptionDetail(EncryptionDetail.Type.InheritanceCheckOnSave);
                                primary.primaryPropertyEncryption.put(DefaultFrameWriter.OWNER_STR, inheritanceCheckOnSave);
                        }
                }
        }

        public void setParent(Frame frame) {
                _oldParent = _parent;
                _parent = frame;
                
                if (_parent == null) { return; }

                final String currentUser = UserSettings.UserName.get();
                final String existingOwner = _parent.getOwner();
                if (currentUser != null && (existingOwner == null || currentUser.compareTo(existingOwner) != 0)) {
                        setOwner(currentUser);
                }
        }

        /**
         * Invalidates this, connected lines and fill
         * 
         * @param trait
         */
        private void invalidateCommonTraitForAll(ItemAppearence trait) {
                invalidateCommonTrait(trait);
                if (isLineEnd()) {
                        boolean hasLinePattern = getLines().get(0).getLinePattern() != null;
                        if (hasLinePattern) {
                                for (Item i : getAllConnected()) {
                                        if (i instanceof Line) {
                                                ((Line) i).invalidateCommonTrait(trait);
                                        }
                                }
                        } else {
                                for (Line line : getLines()) {
                                        line.invalidateCommonTrait(trait);
                                }
                        }
                }
                if (_fillColour != null) {
                        invalidateFill(); // only invalidates if has fill
                }
                for (XRayable x : getEnclosures()) {
                        x.invalidateCommonTrait(trait);
                }

        }

        protected void anchorConstraints()
        {
                // update the position of any dots that are constrained by this one
                for (Constraint c : _constraints) {
                        Item other = c.getOppositeEnd(this);

                        // only set position if the other dot is still fixed to the
                        // frame
                        if (/* this.isFloating() && */!other.isFloating()) {
                                if (c.getType() == Constraint.HORIZONTAL) {
                                        if (isAnchoredY()) {
                                                // Make the 'other' item have the same anchor top/bottom values as this
                                                other._anchoring.setYAnchor(this._anchoring);
                                        }
                                } else if (c.getType() == Constraint.VERTICAL) {
                                        if (isAnchoredX()) {
                                                // Make the 'other' item have the same anchor left/right values as this
                                                other._anchoring.setXAnchor(this._anchoring);
                                        }
                                } else if (c.isDiagonal()) {

                                        System.err.println("Warning: anchorConstraints() not implement for Diagonal setting");
                                }
                        }
                }
        }
        
        /**
         * Sets the position of this item on the screen
         * 
         * @param x
         *            The new X coordinate
         * @param y
         *            The new Y coordinate
         */
        public void setPosition(float x, float y) {
                float deltaX = x - _x;
                float deltaY = y - _y;

                if (deltaX == 0 && deltaY == 0) return;

                invalidateCommonTraitForAll(ItemAppearence.PreMoved);

                _x = x;
                _y = y;

                for (Item i : getEnclosures()) {
                        i.invalidateBounds();
                }
                invalidateBounds();

                // update the position of any dots that are constrained by this one
                for (Constraint c : _constraints) {
                        Item other = c.getOppositeEnd(this);

                        // only set position if the other dot is still fixed to the
                        // frame
                        if (/* this.isFloating() && */!other.isFloating()) {
                                if (c.getType() == Constraint.HORIZONTAL) {
                                        if (other._y != y) {
                                                other.setY(y);
                                        }
                                } else if (c.getType() == Constraint.VERTICAL) {
                                        if (other._x != x) {
                                                other.setX(x);
                                        }
                                } else if (c.isDiagonal()) {
                                        if (Math.abs(other._x - x) != Math.abs(other._y - y)) {

                                                float m1 = c.getGradient();
                                                float c1 = y - m1 * x;
                                                // Now work out the equation for the second line
                                                // Get the first line the other end is attached to that
                                                // is not the diagonal line
                                                List<Line> lines = other.getLines();
                                                // If there is only one line...
                                                if (lines.size() == 1) {
                                                        if (m1 != 0) {
                                                                if (Math.abs(deltaX) > Math.abs(deltaY)) {
                                                                        other.setX((other._y - c1) / m1);
                                                                } else {
                                                                        other.setY(m1 * other._x + c1);
                                                                }
                                                        }
                                                } else if (lines.size() > 1) {
                                                        Line otherLine = lines.get(0);
                                                        Item end = otherLine.getOppositeEnd(other);
                                                        if (end.equals(this)) {
                                                                otherLine = lines.get(1);
                                                                end = otherLine.getOppositeEnd(other);
                                                                assert (!end.equals(this));
                                                        }

                                                        float xDiff = end._x - other._x;
                                                        float yDiff = end._y - other._y;
                                                        if (xDiff == 0) {
                                                                other.setY(m1 * other._x + c1);
                                                        } else if (Math.abs(xDiff) == Math.abs(yDiff)
                                                                        && !this.isFloating() && deltaX == 0
                                                                        && deltaY == 0) {
                                                                if (deltaX == 0) {
                                                                        _x = (_y - other._y) * m1 + other._x;
                                                                } else {
                                                                        _y = (_x - other._x) * m1 + other._y;
                                                                }
                                                        } else {
                                                                float m2 = yDiff / xDiff;
                                                                float c2 = end._y - m2 * end._x;
                                                                float mDiff = m1 - m2;
                                                                if (Math.abs(mDiff) < 0.000001) {
                                                                        assert (false);
                                                                        // TODO how do I handle this case!!
                                                                } else {
                                                                        float newX = (c2 - c1) / mDiff;
                                                                        float newY = m1 * newX + c1;
                                                                        if (other._x != newX
                                                                        /* && other._y != newY */) {
                                                                                other.setPosition(newX, newY);
                                                                        }
                                                                }
                                                        }
                                                }
                                                // Do simultaneous equations to get the new postion for
                                                // the other end of the diagonal line
                                        }
                                }
                        }
                }

                for (Line line : getLines()) {
                        line.invalidateBounds();
                }

                // for (Item item : getAllConnected()) {
                // item.updatePolygon();
                // }

                invalidateCommonTraitForAll(ItemAppearence.PostMoved);

                if (isSurrogate()) {
                        surrogatePropertyInheritance.put(DefaultFrameWriter.POSITION_STR, false);
                        Item primary = getPrimary();
                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.POSITION_STR)) {
                                EncryptionDetail inheritanceCheckOnSave = new EncryptionDetail(EncryptionDetail.Type.InheritanceCheckOnSave);
                                primary.primaryPropertyEncryption.put(DefaultFrameWriter.POSITION_STR, inheritanceCheckOnSave);
                        }
                }
        }

        public void setPosition(Point position) {
                setPosition(position.getX(), position.getY());
        }

        public void setRelativeLink() {
                String link = getLink();
                if (link == null)
                        return;
                assert (_parent != null);

                if (FrameIO.isPositiveInteger(link))
                        return;

                // Check if the link is for the current frameset
                if (_parent.getFramesetName().equalsIgnoreCase(
                                Conversion.getFramesetName(link))) {
                        setLink("" + Conversion.getFrameNumber(link));
                }
        }

        /**
         * Sets the size of this Item. For Text this is the Font size. For Lines and
         * Dots this is the thickness.
         */
        public void setSize(float size) {
        }

        /**
         * Sets the thickness of the item.
         * 
         * @param thick
         */
        public final void setThickness(float thick) {
                setThickness(thick, true);
                
                if (isSurrogate()) {
                        surrogatePropertyInheritance.put(DefaultFrameWriter.THICKNESS_STR, false);
                        Item primary = getPrimary();
                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.THICKNESS_STR)) {
                                EncryptionDetail inheritanceCheckOnSave = new EncryptionDetail(EncryptionDetail.Type.InheritanceCheckOnSave);
                                primary.primaryPropertyEncryption.put(DefaultFrameWriter.THICKNESS_STR, inheritanceCheckOnSave);
                        }
                }
        }

        /**
         * Sets the thickness of this item.
         * 
         * @param thick
         *            the new thickness for the item
         * @param setConnectedThickness
         *            true if all items connected to this item should also have
         *            their thickness set
         */
        public void setThickness(float thick, boolean setConnectedThickness)
        {
                if (thick == _thickness) return;
                
                boolean bigger = thick > _thickness;

                if (!bigger) {
                        if (setConnectedThickness) {
                                // TODO is there a more efficient way of doing this?
                                for (Item i : getConnected()) i.invalidateCommonTrait(ItemAppearence.Thickness);
                        } else {
                                invalidateCommonTrait(ItemAppearence.Thickness);
                        }
                }

                _thickness = thick;
                // update the size of any lines
                /*
                 * TODO: Revise the way line thickness is set to make it more efficient
                 * etc...
                 */
                for (Line line : getLines()) line.setThickness(thick, setConnectedThickness);

                if (setConnectedThickness) invalidateBounds();

                if (bigger) {
                        if (setConnectedThickness) {
                                for (Item i : getConnected()) i.invalidateCommonTrait(ItemAppearence.Thickness);
                        } else {
                                invalidateCommonTrait(ItemAppearence.Thickness);
                        }
                }
        }

        /**
         * Returns the thickness (in pixels) of this Dot.
         * 
         * @return The 'thickness' of this Dot. (returns -1 if the thickness is not
         *         set).
         */
        public float getThickness()     {
                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.THICKNESS_STR)) {
                        return this.getPrimary().getThickness();
                } else {
                        return _thickness;
                }
        }

        /**
         * Sets the Color to use on the top and left sections of this Item's border.
         * If top is NULL, then the Item's background Color will be used.
         * 
         * @param top
         *            The Color to display in the top and left sections of this
         *            Item's border.
         */
        public void setTopShadowColor(Colour top) {
                _colorTopShadow = top;
        }

        public void setWidth(Integer width) throws UnsupportedOperationException
        {
                throw new UnsupportedOperationException("Item type does not support width attribute!");
        }
        
        public void setMinWidth(final Integer width) throws UnsupportedOperationException {
                throw new UnsupportedOperationException("Item type does not support minwidth attribute.");
        }
        
        public void setMaxWidth(Integer width) throws UnsupportedOperationException {
                throw new UnsupportedOperationException("Item type does not support maxwidth attribute");
        }

        public void setRightMargin(int i, boolean fixWidth)
        {
                int newWidth = i - getX() - Item.MARGIN_LEFT;
                if (newWidth < 0) newWidth = 0;
                
                if (!fixWidth) {
                        newWidth *= -1;
                }

                setWidth(newWidth);
        }

        /**
         * Sets the position of this Item on the X axis
         * 
         * @param newX
         *            The position on the X axis to assign to this Item
         */
        public void setX(float newX) {
                setPosition(newX, getY());
                
//              if (isSurrogate()) {
//                      surrogatePropertyInheritance.put(DefaultFrameWriter.POSITION_STR, false);
//                      Item primary = getPrimary();
//                      if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.POSITION_STR)) {
//                              EncryptionDetail inheritanceCheckOnSave = new EncryptionDetail(EncryptionDetail.Type.InheritanceCheckOnSave);
//                              primary.primaryPropertyEncryption.put(DefaultFrameWriter.POSITION_STR, inheritanceCheckOnSave);
//                      }
//              }
        }

        /**
         * Sets the position of this Item on the Y axis
         * 
         * @param newY
         *            The position on the Y axis to assign to this Item
         */
        public void setY(float newY) {
                setPosition(getX(), newY);
                
//              if (isSurrogate()) {
//                      surrogatePropertyInheritance.put(DefaultFrameWriter.POSITION_STR, false);
//                      Item primary = getPrimary();
//                      if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.POSITION_STR)) {
//                              EncryptionDetail inheritanceCheckOnSave = new EncryptionDetail(EncryptionDetail.Type.InheritanceCheckOnSave);
//                              primary.primaryPropertyEncryption.put(DefaultFrameWriter.POSITION_STR, inheritanceCheckOnSave);
//                      }
//              }
        }

        /**
         * Paints any highlighting of this Item. This may include changing the
         * thickness (lines) or painting a box around the item (Text, Images). If
         * val is True then the Graphics Color is changed to the highlight Color, if
         * False then the Graphics Color is left unchanged (for clearing of
         * highlighting).
         * 
         * @param val
         *            True if this Item should be highlighted, false if the
         *            highlighting is being cleared.
         * @return The desired mouse cursor when this Item is highlighted (negative
         *         means no change)
         */
        
        /**
         * 
         * 
         * @return
         */
        public void setHighlightColorToDefault() {
                setHighlightColor(DEFAULT_HIGHLIGHT);
        }

        public void setHighlightColor(Colour c) {
                if (c == null) return;
                
                if (!this.isVisible() && this.hasVector()) {
                        for (Item i : this.getParentOrCurrentFrame().getVectorItems()) {
                                if (i.getEditTarget() == this) {
                                        i.setHighlightColor(c);
                                }
                        }
                }

                _highlightThickness = DEFAULT_HIGHLIGHT_THICKNESS;

                Colour selColor = (c != null) ? c : DEFAULT_HIGHLIGHT;
                if (_highlightColour != c) {
                        _highlightColour = selColor;
                        this.invalidateCommonTrait(ItemAppearence.HighlightColorChanged);
                }

        }

        private void updateArrowPolygon() {
                if (getArrowheadLength() < 0 || getArrowheadRatio() < 0 || getArrowheadNibPerc() < 0)
                        _arrowhead = null;
                else {
                        _arrowhead = Line.createArrowheadPolygon(getX(),getY(),getArrowheadLength(),getArrowheadRatio(),getArrowheadNibPerc()); 
                }
        }

        /** Returns a Bounds which represents the area covered by the item (including its gravity). */
        public abstract Bounds updateBounds();

        public void setHidden(boolean state) {
                this._visible = !state;
        }

        public void setVisible(boolean state) {
                this._visible = state;
        }

        public boolean isVisible() {
                return _visible && !_deleted;
        }

        /**
         * Raised whenever the item is removed, added, no longer in view (That is,
         * when it is not on any of the current frames, of overlays of the current
         * frames) or has become visible. That is, when it is either on a current
         * frame, or an overlay of a current frame.
         * 
         * @param e
         *            The event
         */
        public void onParentStateChanged(ItemParentStateChangedEvent e) {
        }

        /**
         * Sets the highlight mode and colour at the same time.
         * 
         * @param mode The new highlight mode.
         * @param colour The new highlight colour.
         */
        public void setHighlightModeAndColour(HighlightMode mode, Colour colour)
        {
                setHighlightMode(mode);
                setHighlightColor(colour);
        }

        public HighlightMode getHighlightMode() {
                return _highlightMode;
        }

        public void anchor() {
                Frame current = getParentOrCurrentFrame();
                // only set the id if we've moved to a different frame, or if the frame already has an item with that id
                if(!current.equals(_oldParent) || current.getItemWithID(getID()) != null) {
                        setID(current.getNextItemID());
                } else {
                        // System.out.println(this + " - Kept old ID of " + _id);
                }
                setOffset(0, 0);
                setParent(current);

                current.addItem(this, false);
                current.invalidateSorted();
                setRelativeLink();
                setFloating(false);

                // // If its an unconstrained line end check if we should add a
                // constraint
                // if (isLineEnd() && getLines().size() <= 2
                // && getConstraints().size() <= 1) {
                // Constraint existingConstraint = null;
                // List<Constraint> constraints = getConstraints();
                // // Get the existing constraint
                // if (constraints.size() > 0) {
                // existingConstraint = constraints.get(0);
                // }
                // for (Line line : getLines()) {
                // Integer constraintType = line.getPossibleConstraint();
                // if (constraintType != null) {
                // Item oppositeEnd = line.getOppositeEnd(this);
                // if (existingConstraint == null
                // || !existingConstraint.contains(oppositeEnd)) {
                // new Constraint(this, oppositeEnd,
                // getParentOrCurrentFrame().getNextItemID(),
                // constraintType);
                // }
                // }
                // }
                // }
        }

        /**
         * Gets the parent frame if it is set or the current frame if this item does
         * not have a parent set.
         * 
         * @return
         */
        public Frame getParentOrCurrentFrame() {
                // if the item is from an overlay the parent will NOT be null
                if (getParent() == null) {
                        return DisplayController.getCurrentFrame();
                }
                return getParent();
        }

        /**
         * Sets the list of Dots (including this one) that form a closed shape.
         * Passing null sets this dot back to its normal (non-enclosed) state.
         * 
         * @param enclosed
         *            The List of Dots including this one that form a closed shape,
         *            or null.
         */
        public void setEnclosedList(Collection<Item> enclosed) {

                boolean changed = (_enclosure == null && enclosed != null);

                if (_enclosure != null && enclosed == null) {
                        invalidateFill();
                }

                _enclosure = enclosed;

                if (changed) {
                        invalidateFill();
                        ;
                }
        }

        /**
         * Returns the polygon that represents the shape created by all the Dots in
         * this Dot's enclosed list. If the list is null, then null is returned.
         * 
         * @return A Polygon the same shape and position as created by the Dots in
         *         the enclosed list.
         */
        public PolygonBounds getEnclosedShape()
        {
                if (_enclosure == null) return null;

                PolygonBounds poly = new PolygonBounds();
                for (Item d : _enclosure) {
                        poly.addPoint(new Point(d.getX(), d.getY()));
                }

                return poly;
        }

        /**
         * Returns the list of Dots that, along with this Dot, form an enclosed
         * polygon. If this Dot is not part of an enclosure null may be returned.
         * 
         * @return The List of Dots that form an enclosed shape with this Dot, or
         *         null if this Dot is not part of an enclosure.
         */
        public Collection<Item> getEnclosingDots() {
                return _enclosure;
        }

        /**
         * Returns whether this Dot has an assigned enclosure list of other Dots.
         * The result is the same as getEnclosedShape() != null.
         * 
         * @return True if this Dot has an enclosure list of other Dots, false
         *         otherwise.
         */
        public boolean isEnclosed() {
                return _enclosure != null;
        }

        /**
         * True if this item is the end of a line.
         * 
         * @return
         */
        public boolean isLineEnd() {
                // TODO this will need to be redone when enclosure class is added...
                // At the moment enclosures are only circles...we don't want circle
                // centres to be lineEnds
                return _lines.size() > 0;
        }

        public boolean hasEnclosures() {
                return _enclosures.size() > 0;
        }

        /**
         * Method that is called to notify an item that is on the end of a line that
         * its line has changed color.
         * 
         * @param c
         *            the new color for the line
         */
        protected void lineColorChanged(Colour c) {
                for (Line l : getLines()) {
                        if (l.getColor() != c)
                                l.setColor(c);
                }
        }

        /**
         * Checks if this item is off the left or top of the screen
         * 
         * @return
         */
        public boolean offScreenTopOrLeft() {
                Bounds bounds = getBoundingBox();
                
                // Check that the bottom right corner of this item is on the screen
                if (bounds.getMaxX() >= 0 && bounds.getMaxY() >= 0) {
                        return false;
                }
                
                // Check if all the items it is connected to are offscreen
                for (Item i : getAllConnected()) {
                        bounds = i.getBoundingBox();
                        // Check that the bottom right corner of this item is on the screen
                        if (bounds.getMaxX() >= 0 && bounds.getMaxY() >= 0) {
                                return false;
                        }
                }
                
                return true;
        }

        public void setConnectedToAnnotation(boolean val) {
                _connectedToAnnotation = val;
        }

        public boolean isConnectedToAnnotation() {
                return _connectedToAnnotation;
        }

        public boolean hasAction() {
                List<String> actions = getAction();
                return actions != null && actions.size() > 0;
        }

        public void setAction(String action)
        {
                // Want to resize the highlight box for text items if actions are been added
                if (action == null || action.length() == 0) {
                        invalidateCommonTrait(ItemAppearence.LinkChanged);
                }
                
                if (_actions == null || _actions.size() == 0) {
                        invalidateBounds();
                        _actions = new LinkedList<String>();
                } else {
                        _actions.clear();
                }
                
                if (action != null && action.length() > 0) _actions.add(action);
                
                invalidateCommonTrait(ItemAppearence.LinkChanged);
        }

        protected int getLinkYOffset() {
                return 0;
        }

        protected AxisAlignedBoxBounds getLinkDrawArea() {
                return getLinkDrawArea(getX() - LEFT_MARGIN, getY() + getLinkYOffset());
        }

        /**
         * TODO: Revise - it would be good to have a member that defines the link
         * dimensions.
         * 
         * @param x
         *            Left of graphic (i.e not centered)
         * @param y
         *            Above graphic (i.e not centered)
         * 
         * @return The drawing area of the link at the given coordinates.
         */
        public AxisAlignedBoxBounds getLinkDrawArea(int x, int y) {
                return new AxisAlignedBoxBounds(x + 2, y - 1, 8, 8);
        }

        /**
         * Paint the link symbol for the item if it is a
         * 
         * @param g
         */
        protected void paintLink() {
                paintLinkGraphic(getX() - LEFT_MARGIN, getY() + getLinkYOffset());
                paintKeyGraphic(getX() - LEFT_MARGIN, getY() + getLinkYOffset());
                paintPadlockGraphic(getX() - LEFT_MARGIN, getY() + getLinkYOffset());
        }

        /**
         * Paint the link symbol for the item at a given position.
         * 
         * @see #paintLink
         * 
         * @param g
         *            The graphics to paint with
         * 
         * @param x
         *            The x position of the link. Left of graphic (i.e not centered)
         * 
         * @param y
         *            The y position of the link. Above of graphic (i.e not
         *            centered)
         */
        public void paintLinkGraphic(int x, int y) {

                boolean hasLink = hasLink();
                boolean hasAction = hasAction();

                if (hasLink || hasAction) {
                        GraphicsManager g = EcosystemManager.getGraphicsManager();
                        Fill fill = new Fill();
                        Colour colour = null;
                        Point offset = new Point(x, y);
                        
                        if (hasLink && hasAction) {
                                colour = LINK_ACTION_COLOR;
                        } else if (hasLink) {
                                colour = LINK_COLOR;
                        } else if (hasAction) {
                                colour = ACTION_COLOR;
                        }
                        fill.setColour(colour);

                        // Small circles look rubbish without AA. cts16
                        g.setAntialiasing(true);
                        
                        if (hasLink && getLinkMark()) {
                                g.drawOval(offset, getLinkBounds().getDiameters(), 0.0f, null, colour, HIGHLIGHT_STROKE);
                                
                                // if the link is not valid, cross out the circle
                                if (!isLinkValid()) {
                                        g.drawPolygon(getCircleCross(), offset, null, 0.0f, null, colour, HIGHLIGHT_STROKE);
                                }
                        }

                        if (hasAction && getActionMark()) {
                                g.drawOval(offset, getLinkBounds().getDiameters(), 0.0f, fill, colour, HIGHLIGHT_STROKE);

                                // if the link is not valid, cross out the circle
                                if (!isLinkValid() && getLink() != null) {
                                        g.drawPolygon(getCircleCross(), offset, null, 0.0f, null, getParent().getPaintBackgroundColor(), HIGHLIGHT_STROKE);
                                }
                        }
                        
                        g.setAntialiasing(false);
                }
        }

        protected void paintKeyGraphic(int x, int y) {
                Colour fontColour = null;
                switch (this.keyType()) {
                case PartialKey:
                        fontColour = Colour.LIGHT_GRAY;
                        break;
                case FullKey:
                        fontColour = Colour.BLACK;
                        break;
                default:
                        return;
                }
                
                GraphicsManager g = EcosystemManager.getGraphicsManager();
                g.setAntialiasing(true);
                Font font = new Font();
                g.drawString("\uD83D\uDD11", new Point(x,y), font, fontColour);
                g.setAntialiasing(false);
        }
        
        protected void paintPadlockGraphic(int x, int y) {
                String encryptionLabel = this.getEncryptionLabel();
                if (encryptionLabel != null && encryptionLabel.length() > 0) {
                        GraphicsManager g = EcosystemManager.getGraphicsManager();
                        g.setAntialiasing(true);
                        Font font = new Font();
                        g.drawString("\uD83D\uDD12", new Point(x,y), font, Colour.BLACK);
                        g.setAntialiasing(false);
                }
        }
        
        public KeyType keyType() {
                return keyType;
        }
        
        public void setKeyType(String s) {
                try {
                        keyType = KeyType.valueOf(s);
                } catch (IllegalArgumentException e) {
                        keyType = KeyType.NotAKey;
                }
        }

        /**
         * Gets the distance between the start of the text and the left border of
         * the item. This distance changes depending on whether or not the item is
         * linked or has an associated action.
         * 
         * @return the gap size in pixels
         */
        protected int getLeftMargin() {
                return ((getLinkMark() && getLink() != null)
                                || (getActionMark() && getAction() != null) ? MARGIN_LEFT
                                - MARGIN_RIGHT : MARGIN_RIGHT);
        }

        public String getName() {
                return getText();
        }

        final public String getAbsoluteLinkTemplate() {
                return getAbsoluteLink(getLinkTemplate());
        }

        final public String getAbsoluteLinkFrameset() {
                return getAbsoluteLink(getLinkFrameset());
        }

        final public String getAbsoluteLink() {
                return getAbsoluteLink(getLink());
        }

        /**
         * @param link
         * @return
         */
        private String getAbsoluteLink(String link) {
                if (link == null)
                        return null;
                // assert (_parent!= null);
                Frame parent = getParentOrCurrentFrame();
                if (_parent == null) {
                        // if parent is null it is an item on the message box
                        // so it must already be absolute
                        // assert (!FrameIO.isPositiveInteger(link));
                        // return link;

                }

                // if its a relative link then return absolute
                if (FrameIO.isPositiveInteger(link)) {
                        return parent.getFramesetName() + link;
                }
                return link;
        }

        public static String convertToAbsoluteLink(String link) {
                if (link == null)
                        return null;
                // assert (_parent!= null);
                Frame parent = DisplayController.getCurrentFrame();
                assert (parent != null);

                // if its a relative link then return absolute
                if (FrameIO.isPositiveInteger(link)) {
                        return parent.getFramesetName() + link;
                }
                return link;
        }

        /**
         * Sets the x and y values of this item ignoring constraints.
         * 
         * @param x
         *            new x position
         * @param y
         *            new y position
         */
        public void setXY(float x, float y) {
                _x = x;
                _y = y;
        }

        /**
         * Recursive function for getting the path around a shape. This is used to
         * get the path that is painted on the screen.
         * 
         * @param visited
         * @param points
         * @param addToEnd
         * @param toExplore
         */
        public void appendPath(Collection<Line> visited, LinkedList<Point> points,
                        boolean addToEnd, Collection<Line> toExplore) {

                if (addToEnd) {
                        // put the start item points into our list
                        points.addLast(getPosition());
                } else {
                        points.addFirst(getPosition());
                }

                // Find the line that has not been added yet
                LinkedList<Line> lines = new LinkedList<Line>();
                lines.addAll(getLines());

                while (!lines.isEmpty()) {
                        Line l = lines.remove();
                        // if we haven't visited the line yet visit it
                        if (!visited.contains(l)) {
                                visited.add(l);
                                Item otherEnd = l.getOppositeEnd(this);
                                // Add all the unexplored lines to our list
                                while (!lines.isEmpty()) {
                                        l = lines.remove();
                                        // Get the paths for the rest of the lines to be explored
                                        // later
                                        if (!toExplore.contains(l) && !visited.contains(l)) {
                                                toExplore.add(l);
                                        }
                                }
                                otherEnd.appendPath(visited, points, addToEnd, toExplore);
                        }
                }
        }

        /**
         * Gets the size of the enclosure that this item is part of. Used to
         * determine the paint order of items, with smaller items being painted
         * first.
         * 
         * @return the area of the box surrounding the enclosed shape that this item
         *         is part of
         */
        public double getEnclosedArea()
        {
                AxisAlignedBoxBounds box = getEnclosedBox();
                if (box == null) return 0.0;
                return box.getWidth() * box.getHeight();
        }

        /**
         * Gets the box encompassing all points that form an enclosure with this item.
         * 
         * @return An axis-aligned box around all enclosure points.
         */
        public AxisAlignedBoxBounds getEnclosedBox()
        {
                if (_enclosure == null) return null;
                
                return AxisAlignedBoxBounds.getEnclosing(getEnclosedShape());
        }

        public int getEnclosureID()
        {
                return _enclosure == null ? 0 : _enclosure.hashCode();
        }

        /**
         * Returns the Bounds that surrounds this Item representing this Item's
         * 'gravity'.
         * 
         * @return The Bounds surrounding this Item, which represents
         *         this Items 'gravity'.
         */
        public final Bounds getBounds()
        {
                if (_bounds == null) _bounds = updateBounds();
                
                // DEBUG
                if (_bounds == null) {
                        //System.out.println("updateBounds failed!");
                }

                return _bounds;
        }
        
        public final Bounds getOldBounds()
        {
                return _oldBounds;
        }
        
        public final void invalidateBounds()
        {
                if (_bounds != null) _oldBounds = _bounds;
                _bounds = null;
                for (Item surrogate: this.getSurrogates()) {
                        surrogate.invalidateBounds();
                }
        }
        
        public final AxisAlignedBoxBounds getBoundingBox()
        {
                return AxisAlignedBoxBounds.getEnclosing(getBounds());
        }

        /**
         * Shifts the position of the item along the line between this items
         * location and a specified point.
         * 
         * @param origin
         * @param ratio
         */
        public void translate(Point origin, double ratio) {

                invalidateCommonTraitForAll(ItemAppearence.PreMoved);

                _x = (float) (origin.getX() + ratio * (_x - origin.getX()));
                _y = (float) (origin.getY() + ratio * (_y - origin.getY()));
                invalidateBounds();
                for (Line line : getLines())
                        line.invalidateBounds();

                invalidateCommonTraitForAll(ItemAppearence.PostMoved);

        }

        private static int[] LinePatterns = new int[] { 0, 10, 20 };

        /**
         * The rotates through a wheel of dashed lines.
         * 
         * @param amount
         *            number of rotations around the wheel to toggle by.
         */
        public void toggleDashed(int amount) {
                // find the index of the current line pattern
                int[] currentPattern = getLinePattern();

                // Find the current pattern and move to the next pattern in the wheel
                for (int i = 0; i < LinePatterns.length; i++) {
                        if (currentPattern == null || currentPattern[0] == LinePatterns[i]) {
                                i += LinePatterns.length + amount;
                                i %= LinePatterns.length;

                                // if we are at the start of the wheel make it 'null' (solid
                                // line)
                                if (i == 0) {
                                        setLinePattern(null);
                                } else {
                                        setLinePattern(new int[] { LinePatterns[i], LinePatterns[i] });
                                }

                                invalidateCommonTrait(ItemAppearence.ToggleDashed);
                                return;
                        }
                }

        }

        /**
         * For now there can only be one enclosure per item
         * 
         * @param enclosure
         */
        public void addEnclosure(XRayable enclosure) {
                _enclosures.clear();
                _enclosures.add(enclosure);
        }

        /**
         * Gets any XRayable items that have this item as a source.
         * 
         * @return the collection of items that are linked to this item as source.
         *         Guaranteed not to be null.
         */
        public Collection<? extends XRayable> getEnclosures() {
                return _enclosures;
        }

        public void removeEnclosure(Item i) {
                _enclosures.remove(i);

        }

        public boolean isDeleted() {
                return _deleted;
        }

        /**
         * @return The full canvas that this item draws to. Must include
         *         highlighting bounds
         */
        public AxisAlignedBoxBounds getDrawingArea() {

                final AxisAlignedBoxBounds boundingBox = getBoundingBox();
                return ItemUtils.expandRectangle(
                                        boundingBox,
                                        (int) Math.ceil(Math.max(_highlightThickness, getThickness())) + 1 // + 1 to make sure
                );
        }

        /**
         * 
         * @param area
         * @return True if area intersects with this items drawing area.
         */
        public final boolean isInDrawingArea(AxisAlignedBoxBounds area)
        {
                AxisAlignedBoxBounds drawingArea = getDrawingArea();
                
                if (drawingArea == null) return false;
                
                return drawingArea.intersects(area);
        }

        /**
         * Completely invalidates the item - so that it should be redrawn. Note:
         * This is handled internally, it should be rare to invoke this externally
         */
        public final void invalidateAll()
        {
                invalidate(getDrawingArea());
        }

        /**
         * Invalidates areas on the parent frame. Purpose: to be called on specific
         * areas of the item that needs redrawing.
         * 
         * @param damagedAreas
         */
        protected final void invalidate(Bounds[] damagedAreas)
        {
                if (damagedAreas != null) for (Bounds b : damagedAreas) invalidate(b);
        }

        /**
         * Invalidates areas on the parent frame. Purpose: to be called on specific
         * areas of the item that needs redrawing.
         * 
         * @param damagedAreas
         */
        protected final void invalidate(Bounds damagedArea)
        {
                if (damagedArea != null) DisplayController.invalidateItem(this, damagedArea);
        }

        /**
         * Used to invalidate visual traits commonly shared by all items.
         * 
         * @param trait
         */
        public final void invalidateCommonTrait(ItemAppearence trait)
        {
                invalidate(getDamagedArea(trait));

                if (_fillColour != null && (trait == ItemAppearence.Added || trait == ItemAppearence.Removed)) {
                        invalidateFill();
                }
        }

        /**
         * Invalidates fill if has one, even if no color is set.
         */
        public void invalidateFill()
        {
                if (isLineEnd() && _enclosure != null) {
                        invalidate(getEnclosedBox());
                }
        }

        /**
         * Default implementation always uses drawing area except for links, where
         * the link drawing area is used. Override to make item drawing more
         * efficient - defining only parts of the item that needs redrawing.
         * 
         * @see Item.getDrawingArea
         * 
         * @param trait
         *            The visual trait that has changed.
         * 
         * @return The damaged area according to the visual trait that has changed.
         */
        protected AxisAlignedBoxBounds getDamagedArea(ItemAppearence trait)
        {
                if (trait == ItemAppearence.LinkChanged)
                        return getLinkDrawArea(); // Invalidate area where link is drawn

                return getDrawingArea();
        }

        public boolean hasVector() {
                return _overlay instanceof Vector;
        }

        public boolean hasOverlay() {
                return _overlay != null;
        }

        public Vector getVector() {
                if (_overlay instanceof Vector)
                        return (Vector) _overlay;
                return null;
        }

        public void setOverlay(Overlay overlay) {
                _overlay = overlay;
        }

        public boolean dontSave() {
                /*
                 * TODO Mike says: checkout if the ID check is still needed- When will
                 * ID still be -1 when saving a frame? assert (i != null);
                 */
                // make it save stuff that's off the screen so stuff isn't deleted by panning - jts21
                return !_save || !isVisible() || getID() < 0; // || offScreenTopOrLeft();
        }

        public void setAnchorLeft(Integer anchor) {
                this._anchoring.setLeftAnchor(anchor);
                if (anchor != null) {
                        anchorConstraints();
                    setX(anchor);
                }
                
                if (isSurrogate()) {
                        surrogatePropertyInheritance.put(DefaultFrameWriter.ANCHOR_LEFT_STR, false);
                        Item primary = getPrimary();
                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.ANCHOR_LEFT_STR)) {
                                EncryptionDetail inheritanceCheckOnSave = new EncryptionDetail(EncryptionDetail.Type.InheritanceCheckOnSave);
                                primary.primaryPropertyEncryption.put(DefaultFrameWriter.ANCHOR_LEFT_STR, inheritanceCheckOnSave);
                        }
                }
        }

        public void setAnchorRight(Integer anchor) {
                this._anchoring.setRightAnchor(anchor);
                if (anchor != null) {
                        anchorConstraints();
                        setX(DisplayController.getFramePaintArea().getMaxX() - anchor - getBoundsWidth());
                }
                
                if (isSurrogate()) {
                        surrogatePropertyInheritance.put(DefaultFrameWriter.ANCHOR_RIGHT_STR, false);
                        Item primary = getPrimary();
                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.ANCHOR_RIGHT_STR)) {
                                EncryptionDetail inheritanceCheckOnSave = new EncryptionDetail(EncryptionDetail.Type.InheritanceCheckOnSave);
                                primary.primaryPropertyEncryption.put(DefaultFrameWriter.ANCHOR_RIGHT_STR, inheritanceCheckOnSave);
                        }
                }
        }

        public void setAnchorTop(Integer anchor) {
                this._anchoring.setTopAnchor(anchor);
                if (anchor != null) {
                        anchorConstraints();
                        setY(anchor);
                }
                
                if (isSurrogate()) {
                        surrogatePropertyInheritance.put(DefaultFrameWriter.ANCHOR_TOP_STR, false);
                        Item primary = getPrimary();
                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.ANCHOR_TOP_STR)) {
                                EncryptionDetail inheritanceCheckOnSave = new EncryptionDetail(EncryptionDetail.Type.InheritanceCheckOnSave);
                                primary.primaryPropertyEncryption.put(DefaultFrameWriter.ANCHOR_TOP_STR, inheritanceCheckOnSave);
                        }
                }
        }


        public void setAnchorBottom(Integer anchor) {
                this._anchoring.setBottomAnchor(anchor);
                if (anchor != null) {
                        anchorConstraints();
                        setY(DisplayController.getFramePaintArea().getMaxY() - anchor);
                }
                
                if (isSurrogate()) {
                        surrogatePropertyInheritance.put(DefaultFrameWriter.ANCHOR_BOTTOM_STR, false);
                        Item primary = getPrimary();
                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.ANCHOR_BOTTOM_STR)) {
                                EncryptionDetail inheritanceCheckOnSave = new EncryptionDetail(EncryptionDetail.Type.InheritanceCheckOnSave);
                                primary.primaryPropertyEncryption.put(DefaultFrameWriter.ANCHOR_BOTTOM_STR, inheritanceCheckOnSave);
                        }
                }
        }

        public boolean isAnchored()
        {
            return _anchoring.isAnchored();
        }

        public boolean isAnchoredX() {
            return _anchoring.isXAnchored();
        }

        public boolean isAnchoredY() {
            return _anchoring.isYAnchored();
        }

        public Integer getAnchorLeft() {
                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.ANCHOR_LEFT_STR)) {
                        return this.getPrimary().getAnchorLeft();
                } else {
                        return _anchoring.getLeftAnchor();
                }
        }

        public Integer getAnchorRight() {
                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.ANCHOR_RIGHT_STR)) {
                        return this.getPrimary().getAnchorRight();
                } else {
                        return _anchoring.getRightAnchor();
                }
        }

        public Integer getAnchorTop() {
                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.ANCHOR_TOP_STR)) {
                        return this.getPrimary().getAnchorTop();
                } else {
                        return _anchoring.getTopAnchor();
                }
        }

        public Integer getAnchorBottom() {
                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.ANCHOR_BOTTOM_STR)) {
                        return this.getPrimary().getAnchorBottom();
                } else {
                        return _anchoring.getBottomAnchor();
                }
        }

        public String getText() {
                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.TEXT_STR)) {
                        return this.getPrimary().getText();
                } else {
                        return "@" + getClass().getSimpleName() + ":" + getID();
                }
        }

        public void setText(String text) {
        }

        public boolean recalculateWhenChanged() {
                return false;
        }

        public boolean update() {
                return calculate(getText());
        }

        public Collection<Item> getEnclosedItems() {
                return FrameUtils.getItemsEnclosedBy(this.getParentOrCurrentFrame(),
                                this.getEnclosedShape());
        }

        public Collection<Text> getEnclosedNonAnnotationText() {
                Collection<Text> items = new LinkedHashSet<Text>();
                for (Item t : getEnclosedItems()) {
                        if (t instanceof Text && !t.isAnnotation())
                                items.add((Text) t);
                }

                return items;
        }

        public void dispose() {
                setParent(null);
        }

        /**
         * @return
         */
        protected boolean hasVisibleBorder() {
                return getThickness() > 0 && !isLineEnd() && getBorderColor() != null;
        }

        public Frame getChild() {
                String childName = getAbsoluteLink();
                if (childName != null) {
                        return FrameIO.LoadFrame(childName);
                }
                return null;
        }

        public boolean hasLink() {
                return _link != null;
        }

        protected void anchorConnectedOLD(AnchorEdgeType anchorEdgeType, Float delta) {
                // Check for a more efficient way to do this!!
                // Invalidate all the items
                for (Item i : this.getAllConnected()) {
                        i.invalidateAll();
                }
                // Move the items
                for (Item i : this.getAllConnected()) {
                        if (i.isLineEnd()) {
                                if (delta != null) {
                                        if ((anchorEdgeType == AnchorEdgeType.Left) || (anchorEdgeType == AnchorEdgeType.Right)) {
                                                // 'delta' encodes a horizontal (x) move
                                                if (anchorEdgeType == AnchorEdgeType.Left) {
                                                        i.setAnchorLeft(null);
                                                }
                                                else {
                                                        // must be Right
                                                        i.setAnchorRight(null);
                                                }
                                                
                                                i.setXY(i.getX() + delta, i.getY());
                                        }
                                        if ((anchorEdgeType == AnchorEdgeType.Top) || (anchorEdgeType == AnchorEdgeType.Bottom)) {
                                                // 'delta; encodes a vertical (y) move
                                                if (anchorEdgeType == AnchorEdgeType.Top) {
                                                        i.setAnchorTop(null);
                                                }
                                                else {
                                                        // must be Bottom
                                                        i.setAnchorBottom(null);
                                                }
                                                i.setXY(i.getX(), i.getY() + delta);
                                        }
                                        
                                }
                        }
                }
                // Invalidate them again!!
                for (Item i : this.getAllConnected()) {
                        i.invalidateBounds();
                        i.invalidateAll();
                }
        }

        protected void anchorConnected(AnchorEdgeType anchorEdgeType, Float delta) {
                
                // Check for a more efficient way to do this!!
                // Invalidate all the items
                for (Item i : this.getAllConnected()) {
                        i.invalidateAll();
                }
                
                // Move the items
                for (Item i : this.getAllConnected()) {
                        if (i.isLineEnd()) {
                                if (delta != null) {
                                        if ((anchorEdgeType == AnchorEdgeType.Left) || (anchorEdgeType == AnchorEdgeType.Right)) {
                                                // 'delta' encodes a horizontal (x) move
                                                if (anchorEdgeType == AnchorEdgeType.Left) {
                                                        // Processing a Left anchor
                                                        // => Anything connected that is *not* anchored to the right should be moved by 'delta'
                                                        if (i.getAnchorRight()==null) {
                                                                i.setXY(i.getX() + delta, i.getY());
                                                        }
                                                }
                                                else {
                                                        // Processing a Right anchor
                                                        // => Anything connected that is *not* anchored to the left should be moved by 'delta'
                                                        if (i.getAnchorLeft()==null) {
                                                                i.setXY(i.getX() + delta, i.getY());
                                                        }
                                                }

                                        }
                                        if ((anchorEdgeType == AnchorEdgeType.Top) || (anchorEdgeType == AnchorEdgeType.Bottom)) {
                                                // 'delta; encodes a vertical (y) move
                                                if (anchorEdgeType == AnchorEdgeType.Top) {
                                                        // Processing a Top anchor
                                                        // => Anything connected that is *not* anchored to the bottom should be moved by 'delta'
                                                        if (i.getAnchorBottom()==null) {
                                                                i.setXY(i.getX(), i.getY() + delta);
                                                        }
                                                }
                                                else {
                                                        // Processing a Bottom anchor
                                                        // => Anything connected that is *not* anchored to the top should be moved by 'delta'
                                                        if (i.getAnchorTop()==null) {
                                                                // must be Bottom
                                                                //i.setAnchorBottom(null);
                                                                i.setXY(i.getX(), i.getY() + delta);
                                                        }
                                                }
                                        }               
                                }
                        }
                }
                
                anchorConstraints();
                
                // Invalidate them again!!
                for (Item i : this.getAllConnected()) {
                        i.invalidateBounds();
                        i.invalidateAll();
                }
        }
        /**
         * Sets the item to pickup when the user attempts to pick this item up.
         * EditTarget has a value of 'this' by default but may be set to other
         * values if this item is on a vector.
         * 
         * @param target
         *            the item to be copied or picked up when the user attempts to
         *            edit this item.
         */
        public void setEditTarget(Item target) {
                _editTarget = target;
        }

        /**
         * Gets the item to pickup when the user attempts to pick this item up.
         * EditTarget has a value of 'this' by default but may be set to other
         * values if this item is on a vector.
         */
        public Item getEditTarget() {
                return _editTarget;
        }

        public void scale(Float scale, int originX, int originY) {
                setXY((getX() - originX) * scale + originX, (getY() - originY) * scale + originY);
                setArrowheadLength(getArrowheadLength() * scale);

                float thickness = getThickness();
                if (thickness > 0)
                        setThickness(thickness * scale, false);

                // DONT PUT SIZE IN HERE CAUSE IT STUFFS UP CIRCLES

                invalidateBounds();
        }

        protected boolean isVectorItem() {
                return _editTarget != this;
        }

        public AttributeValuePair getAttributeValuePair() {
                if (_attributeValuePair == null) {
                        _attributeValuePair = new AttributeValuePair(getText());
                }
                return _attributeValuePair;
        }

        /*
         * private static Set<Object> _locks = new HashSet<Object>();
         * 
         * public static void lock(Object itemToLock) { _locks.add(itemToLock); }
         * 
         * public static void unlock(Object itemToUnlock) {
         * _locks.remove(itemToUnlock); }
         * 
         * public static boolean isLocked(Object item) { return
         * _locks.contains(item); }
         */

        public void setSave(boolean state) {
                _save = state;
        }

        public boolean getSave() {
                return _save;
        }

        public void setAutoStamp(Float rate) {
                _autoStamp = rate;
        }

        public Float getAutoStamp() {
                return _autoStamp;
        }

        public boolean isAutoStamp() {
                return _autoStamp != null && _autoStamp >= 0.0;
        }
        
        public int getMagnetizedItemLeft() {
                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.MAGNETIZED_ITEM_LEFT_STR)) {
                        return this.getPrimary().getMagnetizedItemLeft();
                } else {
                        if(_magnetizedItemLeft != null) return _magnetizedItemLeft.getID();
                        else return -1;
                }
        }
        
        public void setMagnetizedItemLeft(final Item item) {
                _magnetizedItemLeft = item;
        }
        
        public void setMagnetizedItemLeft(final int id) {
                setMagnetizedItemLeft(this.getParent().getItemWithID(id));
                
                if (isSurrogate()) {
                        surrogatePropertyInheritance.put(DefaultFrameWriter.MAGNETIZED_ITEM_LEFT_STR, false);
                        Item primary = getPrimary();
                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.MAGNETIZED_ITEM_LEFT_STR)) {
                                EncryptionDetail inheritanceCheckOnSave = new EncryptionDetail(EncryptionDetail.Type.InheritanceCheckOnSave);
                                primary.primaryPropertyEncryption.put(DefaultFrameWriter.MAGNETIZED_ITEM_LEFT_STR, inheritanceCheckOnSave);
                        }
                }
        }
        
        public int getMagnetizedItemRight() {
                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.MAGNETIZED_ITEM_RIGHT_STR)) {
                        return this.getPrimary().getMagnetizedItemRight();
                } else {
                        if(_magnetizedItemRight != null) return _magnetizedItemRight.getID();
                        else return -1;
                }
        }
        
        public void setMagnetizedItemRight(final Item item) {
                _magnetizedItemRight = item;
        }
        
        public void setMagnetizedItemRight(final int id) {
                setMagnetizedItemRight(this.getParent().getItemWithID(id));
                
                if (isSurrogate()) {
                        surrogatePropertyInheritance.put(DefaultFrameWriter.MAGNETIZED_ITEM_RIGHT_STR, false);
                        Item primary = getPrimary();
                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.MAGNETIZED_ITEM_RIGHT_STR)) {
                                EncryptionDetail inheritanceCheckOnSave = new EncryptionDetail(EncryptionDetail.Type.InheritanceCheckOnSave);
                                primary.primaryPropertyEncryption.put(DefaultFrameWriter.MAGNETIZED_ITEM_RIGHT_STR, inheritanceCheckOnSave);
                        }
                }
        }
        
        public int getMagnetizedItemTop() {
                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.MAGNETIZED_ITEM_TOP_STR)) {
                        return this.getPrimary().getMagnetizedItemTop();
                } else {
                        if(_magnetizedItemTop != null) return _magnetizedItemTop.getID();
                        else return -1;
                }
        }
        
        public void setMagnetizedItemTop(final Item item) {
                _magnetizedItemTop = item;
        }
        
        public void setMagnetizedItemTop(final int id) {
                setMagnetizedItemTop(this.getParent().getItemWithID(id));
                
                if (isSurrogate()) {
                        surrogatePropertyInheritance.put(DefaultFrameWriter.MAGNETIZED_ITEM_TOP_STR, false);
                        Item primary = getPrimary();
                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.MAGNETIZED_ITEM_TOP_STR)) {
                                EncryptionDetail inheritanceCheckOnSave = new EncryptionDetail(EncryptionDetail.Type.InheritanceCheckOnSave);
                                primary.primaryPropertyEncryption.put(DefaultFrameWriter.MAGNETIZED_ITEM_TOP_STR, inheritanceCheckOnSave);
                        }
                }
        }
        
        public int getMagnetizedItemBottom() {
                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.MAGNETIZED_ITEM_BOTTOM_STR)) {
                        return this.getPrimary().getMagnetizedItemBottom();
                } else {
                        if(_magnetizedItemBottom != null) return _magnetizedItemBottom.getID();
                        else return -1;
                }
        }
        
        public void setMagnetizedItemBottom(final Item item) {
                _magnetizedItemBottom = item;
        }
        
        public void setMagnetizedItemBottom(final int id) {
                setMagnetizedItemBottom(this.getParent().getItemWithID(id));
                
                if (isSurrogate()) {
                        surrogatePropertyInheritance.put(DefaultFrameWriter.MAGNETIZED_ITEM_BOTTOM_STR, false);
                        Item primary = getPrimary();
                        if (subjectToInheritanceCheckOnSave(DefaultFrameWriter.MAGNETIZED_ITEM_BOTTOM_STR)) {
                                EncryptionDetail inheritanceCheckOnSave = new EncryptionDetail(EncryptionDetail.Type.InheritanceCheckOnSave);
                                primary.primaryPropertyEncryption.put(DefaultFrameWriter.MAGNETIZED_ITEM_BOTTOM_STR, inheritanceCheckOnSave);
                        }
                }
        }
        
        public String getEncryptionLabel() {
                if (isSurrogate() && surrogatePropertyInheritance.get(DefaultFrameWriter.ENCRYPTION_LABEL_STR)) {
                        return this.getPrimary().getEncryptionLabel();
                } else {
                        return _encryptionLabel;
                }
        }
        
        public void setEncryptionLabel(String label) {
                this.getSurrogates().clear();
                this._encryptionLabel = label;
                
                if (this.getParent().getFrameEncryptionLabel() == null) {
                        MessageBay.displayMessage("Items can only be entrypted if the frame they are on is.");
                        return;
                }
                LabelInfo labelResult = Label.getLabel(label);
                if (!labelResult.is(LabelResult.SuccessResolveLabelToKey)) {
                        MessageBay.displayMessage(labelResult.toString());
                        this._encryptionLabel = null;
                        return;
                }
                
                //Setup surrogate items.
                Item copy = this.copy();
                if (copy.isAnnotation()) {
                        if (ItemUtils.startsWithTag(copy, ItemUtils.TAG_IMAGE, true)) {
                                String text = copy.getText();
                                String size = "";
                                
                                // remove @i tag
                                text = text.replaceFirst("@i:", "");
                                text = text.replaceAll("\n", "");
                                text = text.trim();

                                int dotPos = text.indexOf('.');
                                if (dotPos >= 0) {
                                        int endOfFileNamePos = text.indexOf(' ', dotPos);
                                        if (endOfFileNamePos >= 0) {
                                                size = text.substring(endOfFileNamePos).trim();
                                        }
                                }
                                
                                String copyText = ItemUtils.GetTag(ItemUtils.TAG_IMAGE) + ": " + Picture.REDACTED_IMAGE_NAME + " " + size;
                                copy.setText(copyText.trim());
                                copy.setVisible(true);
                        }
                } else if (copy instanceof Text) {
                        copy.setText("Encrypted"); 
                }
                
                // Encrypt XRayables representative files and update pointer.
                Collection<? extends XRayable> xrayables = this.getEnclosures();
                for (XRayable xray: xrayables) {
                        if (xray instanceof Picture) {
                                EncryptedImage.encryptImage((Picture) xray, labelResult.key);
                                Text source = xray._source;
                                String oldName = xray.getName();
                                String newName = oldName.substring(0, oldName.lastIndexOf('.')) + EncryptedImage.EXPEDITEE_ENCRYPTED_IMAGE_EXTENSION;
                                source.setText(source.getText().replace(oldName, newName));
                        }
                }
                
                this.addToSurrogates(copy);
        }
        
        public void setEncryptionLabelOnLoad(String label) {
                this._encryptionLabel = label;
        }

        /**
         * Replaces the given dot item with a text item displaying the given character.
         * 
         * @param dot
         *              The Dot item to replace.
         * 
         * @param ch
         *              The character to display as the text for the created Text item.
         * 
         * @return
         *              The created Text item.
         */
        public static Text replaceDot(Item dot, char ch) {
                // TODO: Should this make sure 'dot' is actually a Dot and not some other item? cts16
                Text text = Text.createText(ch);
                Item.DuplicateItem(dot, text);
                FrameUtils.setLastEdited(text);

                // Copy the lines list so it can be modified
                List<Line> lines = new LinkedList<Line>(dot.getLines());
                for (Line line : lines)
                        line.replaceLineEnd(dot, text);
                Frame current = dot.getParentOrCurrentFrame();
                current.removeItem(dot);
                ItemUtils.EnclosedCheck(current.getSortedItems());
                return text;
                // TODO: Should this add the newly-created Text item to the frame? cts16
        }

        /**
         * Replaces the given text item with a dot
         */
        public static Item replaceText(Item text) {
                Item dot = new Dot(text.getX(), text.getY(), text.getID());
                Item.DuplicateItem(text, dot);

                List<Line> lines = new LinkedList<Line>();
                lines.addAll(text.getLines());
                if (lines.size() > 0)
                        dot.setColor(lines.get(0).getColor());
                for (Line line : lines) {
                        line.replaceLineEnd(text, dot);
                }
                text.delete();
                Frame current = text.getParentOrCurrentFrame();
                current.addItem(dot);
                DisplayController.setCursor(Item.DEFAULT_CURSOR);
                ItemUtils.EnclosedCheck(current.getSortedItems());
                return dot;
        }

        public Set<Item> getSurrogates() {
                return surrogateItems;
        }
                
        private void setAsSurrogateFor(Item primary) {
                this.surrogateFor = primary;
        }

        public void addToSurrogates(Item surrogate) {
                if (this.getEncryptionLabel() == null) {
                        MessageBay.displayMessage("Only Items with encryption labels can have surrogates.");
                        return;
                }
                
                this.getParent().removeItem(surrogate);
                this.surrogateItems.add(surrogate);
                surrogate.setAsSurrogateFor(this);
                this.getParent().addItem(surrogate);
                
                EncryptionDetail reencryptOnSave = new EncryptionDetail(EncryptionDetail.Type.ReencryptOnSave);
                EncryptionDetail unencryptedOnSave = new EncryptionDetail(EncryptionDetail.Type.UnencryptedOnSave);
                
                for (Character tag: DefaultFrameWriter.getItemCharTags().keySet()) {
                        if (tag == 'T') {
                                primaryPropertyEncryption.put(tag + "", reencryptOnSave.clone());
                        } else {
                                primaryPropertyEncryption.put(tag + "", unencryptedOnSave.clone());
                        }
                                        
                        if (tag == 'T' || tag == 'S') {
                                surrogate.surrogatePropertyInheritance.put(tag + "", false);
                        } else {
                                surrogate.surrogatePropertyInheritance.put(tag + "", true);
                        }
                }
                
                for (String tag: DefaultFrameWriter.getItemStrTags().keySet()) {
                        primaryPropertyEncryption.put(tag, unencryptedOnSave.clone());
                        surrogate.surrogatePropertyInheritance.put(tag + "", true);
                }
        }
        
        public boolean isSurrogate() {
                return this.surrogateFor != null;
        }
        
        public Item getPrimary() {
                return this.surrogateFor;
        }
        
        public EncryptionDetail getEncryptionDetailForTag(String tag) {
                EncryptionDetail encryptionDetail = primaryPropertyEncryption.get(tag);
                
                if (encryptionDetail == null) {
                        EncryptionDetail unencryptedOnSave = new EncryptionDetail(EncryptionDetail.Type.UnencryptedOnSave);
                        return unencryptedOnSave;
                } else {
                        return encryptionDetail;
                }
        }
        
        public void setEncryptionDetailForTag(String tag, EncryptionDetail encryptionDetail) {
                primaryPropertyEncryption.put(tag, encryptionDetail);
        }
        
        public boolean isTagInherited(String tag) {
                return surrogatePropertyInheritance.get(tag);
        }
        
        public void setTagNotInherited(String tag) {
                surrogatePropertyInheritance.put(tag, false);
        }
        
        public boolean hasAccessToItemAsPrimary() {
                String label = this.getEncryptionLabel();
                if (this.isSurrogate() || label == null || label.length() == 0) {
                        return true;
                }
                
                return Label.getLabel(label).is(LabelResult.SuccessResolveLabelToKey);
        }
        

        /**
         * If when setting a property, we find that the primary has a undeciphered value, when we must continue using that undeciphered value
         * when eventually saving.
         * @return
         */
        protected boolean subjectToInheritanceCheckOnSave(String tag) {
                if (tag.equals(DefaultFrameWriter.TYPE_AND_ID_STR)) {
                        return false;
                }
                Item primary = getPrimary();
                if (primary == null) return false;
                EncryptionDetail primaryItemTagEncryptionDetail = primary.primaryPropertyEncryption.get(tag);
                Type primaryItemTagEncryptionDetailType = primaryItemTagEncryptionDetail.getEncryptionDetailType();
                return primaryItemTagEncryptionDetailType != EncryptionDetail.Type.UseUndecipheredValueOnSave;
        }

        public boolean acceptsKeyboardEnter() {
                return _acceptsKeyboardEnter;
        }
                
        public void setAcceptsEnter(boolean value) {
                if (this.getText() != null && this.getText().equals("Beep")) {
                        System.err.println();
                }
                _acceptsKeyboardEnter = value;
        }
}