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

package org.expeditee.items;

import java.awt.Color;
import java.awt.Cursor;
import java.awt.Dimension;
import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.Polygon;
import java.awt.Rectangle;
import java.awt.geom.Area;
import java.util.ArrayList;
import java.util.Collection;
import java.util.ConcurrentModificationException;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;

import org.expeditee.actions.Actions;
import org.expeditee.actions.Simple;
import org.expeditee.gui.DisplayIO;
import org.expeditee.gui.Frame;
import org.expeditee.gui.FrameGraphics;
import org.expeditee.gui.FrameIO;
import org.expeditee.gui.FrameUtils;
import org.expeditee.io.Conversion;
import org.expeditee.io.Logger;
import org.expeditee.simple.Context;
import org.expeditee.stats.AgentStats;

/**
 * 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 {

        // contains all dots (including this one) that form an enclosure
        // if this dot is part of an enclosing shape
        private Collection<Item> _enclosure = null;

        protected boolean _connectedToAnnotation = false;

        public static int PERMISSION_NONE = 0;

        public static int PERMISSION_FOLLOW_LINKS = 1;

        public static int PERMISSION_COPY = 2;

        public static int PERMISSION_TDFC = 3;

        public static int PERMISSION_FULL = 4;

        public static final int NEAR_DISTANCE = 15;

        /**
         * The default Color to draw highlighting in
         */
        public static final int DEFAULT_HIGHLIGHT_THICKNESS = 2;

        public static final Color DEFAULT_HIGHLIGHT = Color.RED;

        public static final Color DEPRESSED_HIGHLIGHT = Color.GREEN;

        public static final Color DISCONNECT_HIGHLIGHT = Color.BLUE;

        public static final Color LINK_COLOR = Color.BLACK;

        public static final Color ACTION_COLOR = Color.BLACK;

        public static final Color LINK_ACTION_COLOR = Color.RED;

        public static final Color DEFAULT_FOREGROUND = Color.BLACK;

        public static final Color DEFAULT_BACKGROUND = org.expeditee.gui.DisplayIO.DEFAULT_BACKGROUND;

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

        public static final Color GREEN = Color.GREEN.darker();

        /**
         * The Colors cycled through when using function keys to set the Color of
         * this Item.
         */
        public static Color[] COLOR_WHEEL = { Color.BLACK, Color.RED, Color.BLUE,
                        Item.GREEN, Color.MAGENTA, Color.YELLOW.darker(),
                        DisplayIO.DEFAULT_BACKGROUND };

        public static Color[] FILL_COLOR_WHEEL = { Color.BLACK,
                        new Color(255, 150, 150), new Color(150, 150, 255),
                        new Color(150, 255, 150), new Color(255, 150, 255),
                        new Color(255, 255, 100), DisplayIO.DEFAULT_BACKGROUND };

        public static final int UNCHANGED_CURSOR = -100;

        public static final int DEFAULT_CURSOR = Cursor.DEFAULT_CURSOR;

        public static final int HIDDEN_CURSOR = Cursor.CUSTOM_CURSOR;

        public static final int TEXT_CURSOR = Cursor.TEXT_CURSOR;

        public static final int CROP_CURSOR = Cursor.CROSSHAIR_CURSOR;

        public static final int JUSTIFICATION_NONE = -1;

        public static final int JUSTIFICATION_FULL = 0;

        public static final int JUSTIFICATION_CENTER = 1;

        public static final int JUSTIFICATION_RIGHT = 2;

        public static final int JUSTIFICATION_LEFT = 3;

        public static final int POINTTYPE_SQUARE = -1;

        public static final int POINTTYPE_CIRCLE = 0;

        public static void DuplicateItem(Item source, Item dest) {
                dest.setX(source.getX());
                dest.setY(source.getY());

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

                dest.setBackgroundColor(source.getBackgroundColor());
                dest.setBottomShadowColor(source.getBottomShadowColor());
                dest.setColor(source.getColor());

                dest.setData(source.getData());
                dest.setFillColor(source.getFillColor());
                dest.setFillPattern(source.getFillPattern());

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

                dest.setMaxSize(source.getMaxSize());
                dest.setOffset(source.getOffset());
                dest.setOwner(source.getOwner());
                dest.setThickness(source.getThickness());
                dest.setSize(source.getSize());
                dest.setTopShadowColor(source.getTopShadowColor());
                dest.setLinePattern(source.getLinePattern());

                dest.setFloating(source.isFloating());
                dest.setArrow(source.getArrowheadLength(), source.getArrowheadRatio());

                dest.setParent(source.getParent());
                Frame parent = source.getParentOrCurrentFrame();
                // 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(source.getParentOrCurrentFrame().getNextItemID());
                }
        }

        public static int getGravity() {
                return org.expeditee.gui.UserSettings.Gravity;
        }

        public static boolean showLineHighlight() {
                return org.expeditee.gui.UserSettings.LineHighlight;
        }

        public enum SelectedMode {
                None, Enclosed, Connected, Disconnect, Normal
        }

        public void setSelectedMode(SelectedMode mode) {
                setSelectedMode(mode, DEFAULT_HIGHLIGHT);
        }

        protected SelectedMode _mode = SelectedMode.None;

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

        private int _x;

        private int _y;

        private int _id;

        private String _creationDate = null;

        private boolean _linkMark = true;

        private boolean _actionMark = true;

        private boolean _highlight = true;

        private Dimension _maxSize = null;

        private String _owner = null;

        private String _link = null;

        private StringBuffer _data = new StringBuffer();

        private List<String> _actionCursorEnter = null;

        private List<String> _actionCursorLeave = null;

        private List<String> _actionEnterFrame = null;

        private List<String> _actionLeaveFrame = null;

        public int Permission = PERMISSION_FULL;

        private Color _colorFill = null;

        private Color _color = null;

        private Color _highlightColor = DEFAULT_HIGHLIGHT;

        private Color _colorBackground = null;

        private Color _colorTopShadow = null;

        private Color _colorBottomShadow = null;

        // the link\action circle
        private Polygon _circle = null;

        // the invalid link cross
        private Polygon _circleCross = null;

        private Frame _parent = null;

        protected int _highlightThickness = 2;

        // arrowhead parameters
        private int _arrowheadLength = 0;

        private double _arrowheadRatio = DEFAULT_ARROWHEAD_RATIO;

        private Polygon _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 LinkedList<String> _actions = null;

        private String _link_frameset = null;

        private String _link_template = null;

        private String _fillPattern = null;

        private boolean _visible = true;

        private SelectedMode _lastMode = SelectedMode.None;

        private float _thickness = -1.0F;

        protected Item() {
                _creationDate = Logger.EasyDateFormat("ddMMMyyyy:HHmm");
        }

        /**
         * Adds an action to this Item.
         * 
         * @param action
         *            The KMS action language 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);
        }

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

                for (Line line : getLines()) {
                        if (!connected.contains(line))
                                line.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 x
         *            The x coordinate to check
         * @param y
         *            The y coordinate to check
         * @return True if the Shape around this Item contains the given x,y pair,
         *         false otherwise.
         */
        public boolean contains(int x, int y) {
                return getPolygon().contains(x, y);
        }

        /**
         * 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() {
                setVisible(false);
        }

        public boolean equals(Object o) {
                if (o instanceof Item) {
                        Item i = (Item) o;
                        return i.getID() == getID()
                                        && ((i.getParent() == _parent) || (i.getParent() != null && i
                                                        .getParent().equals(_parent)));

                } else
                        return false;
        }

        final public String getAbsoluteLink() {
                String link = getLink();

                if (link == null)
                        return null;
                // assert (_parent!= null);
                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;
        }

        /**
         * Returns a list of any action code (KMS action language) 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() {
                return _actions;
        }

        public List<String> getActionCursorEnter() {
                return _actionCursorEnter;
        }

        public List<String> getActionCursorLeave() {
                return _actionCursorLeave;
        }

        public List<String> getActionEnterFrame() {
                return _actionEnterFrame;
        }

        public List<String> getActionLeaveFrame() {
                return _actionLeaveFrame;
        };

        public boolean getActionMark() {
                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 (!hasVisibleArrow())
                        return null;

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

                return getArrowheadLength() + " " + ratio;
        }

        public Polygon getArrowhead() {
                return _arrowhead;
        }

        public int getArrowheadLength() {
                return _arrowheadLength;
        }

        public double getArrowheadRatio() {
                return _arrowheadRatio;
        }

        public Color getBackgroundColor() {
                return _colorBackground;
        }

        /**
         * 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 Color 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 getPolygon().getBounds().height;
        }

        /**
         * 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 getPolygon().getBounds().width;
        }

        protected Polygon getCircle() {
                if (_circle == null) {
                        int points = 16;

                        double radians = 0.0;
                        int xPoints[] = new int[points];
                        int yPoints[] = new int[xPoints.length];

                        for (int i = 0; i < xPoints.length; i++) {
                                // circle looks best if these values are not related to gravity
                                xPoints[i] = (int) (3.5 * Math.cos(radians)) + 6;// (2 *
                                // GRAVITY);
                                yPoints[i] = (int) (3.5 * Math.sin(radians)) + 3;// GRAVITY;
                                radians += (2.0 * Math.PI) / xPoints.length;
                        }

                        _circle = new Polygon(xPoints, yPoints, xPoints.length);
                }

                return _circle;
        }

        protected Polygon getCircleCross() {

                if (_circleCross == null) {
                        _circleCross = new Polygon();

                        Rectangle bounds = getCircle().getBounds();
                        int x1 = (int) bounds.getMinX();
                        int x2 = (int) bounds.getMaxX();
                        int y1 = (int) bounds.getMinY();
                        int y2 = (int) bounds.getMaxY();
                        int midX = ((x2 - x1) / 2) + x1;
                        int midY = ((y2 - y1) / 2) + y1;

                        _circleCross.addPoint(x1, y1);
                        _circleCross.addPoint(x2, y2);
                        _circleCross.addPoint(midX, midY);
                        _circleCross.addPoint(x1, y2);
                        _circleCross.addPoint(x2, y1);
                        _circleCross.addPoint(midX, midY);
                }

                return _circleCross;
        }

        public Color getColor() {
                return _color;
        }

        public Collection<Item> getConnected() {
                List<Item> conn = new LinkedList<Item>();
                conn.add(this);

                conn.addAll(getLines());
                return conn;
        }

        public String getConstraintIDs() {
                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 getData() {
                if (_data != null && _data.length() > 0)
                        return _data.toString();
                return null;
        }

        public String getDateCreated() {
                return _creationDate;
        }

        public Color getFillColor() {
                return _colorFill;
        }

        public String getFillPattern() {
                return _fillPattern;
        }

        public String getFirstAction() {
                if (_actions == null)
                        return null;
                return _actions.getFirst();
        }

        public boolean getHighlight() {
                return _highlight;
        }

        public Color getHighlightColor() {
                return _highlightColor;
        }

        /**
         * Returns the ID of this Item, which must be unique for the Frame.
         * 
         * @return The ID of this Item.
         */
        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() {
                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() {
                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() {
                return _link;
        }

        public String getLinkFrameset() {
                return _link_frameset;
        }

        public boolean getLinkMark() {
                return _linkMark;
        }

        public String getLinkTemplate() {
                return _link_template;
        }

        public Dimension getMaxSize() {
                return _maxSize;
        }

        public Point getOffset() {
                return _offset;
        }

        public String getOwner() {
                return _owner;
        }

        public Color getPaintBackgroundColor() {
                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 Color getPaintColor() {
                if (_color == null) {
                        if (getParent() != null)
                                return getParent().getPaintForegroundColor();

                        if (DisplayIO.getCurrentFrame() == null)
                                return DEFAULT_FOREGROUND;

                        return DisplayIO.getCurrentFrame().getPaintForegroundColor();
                }

                return _color;
        }

        protected Color getPaintHighlightColor() {
                if (getParent() != null
                                && getParent().getPaintBackgroundColor()
                                                .equals(_highlightColor))
                        return getParent().getPaintForegroundColor();

                return _highlightColor;
        }

        public Frame getParent() {
                return _parent;
        }

        /**
         * Returns the Shape that surrounds this Item representing this Item's
         * 'gravity'.
         * 
         * @return The Shape (rectangle) surrounding this Item, which represents
         *         this Items 'gravity'.
         */
        public abstract Polygon getPolygon();

        public Point getPosition() {
                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 int getSize() {
                return -1;
        }

        /**
         * 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 Color getTopShadowColor() {
                return _colorTopShadow;
        }

        public String getTypeAndID() {
                return "T " + getID();
        }

        public int getWidth() {
                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() {
                return _x;
        }

        /**
         * Returns the Y coordinate of this Item on the screen
         * 
         * @return The Y coordinate of this Item on the screen
         */
        public int getY() {
                return _y;
        }

        protected boolean hasVisibleArrow() {
                return false;
        }

        /**
         * Checks if the given Shape intersects with the Shape around this Item.
         * Note: Both Shape objects should be rectangles for this to work properly.
         * 
         * @param s
         *            The Shape to check.
         * @return True if the two Shapes overlap, False otherwise.
         */
        public boolean intersects(Polygon p) {
                if (p == null)
                        return false;

                // return p.getBounds().intersects(getArea().getBounds());
                Area a = new Area(p);

                a.intersect(this.getArea());
                return !a.isEmpty();
        }

        /**
         * 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().getFrameNameItem() != this)
                        return false;
                return true;
        }

        public boolean isFrameTitle() {
                if (this.getParent() == null || this.getParent().getTitle() != 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() {
                return _mode != SelectedMode.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;
        }

        public boolean isNear(int x, int y) {

                int xLeft = getPolygon().getBounds().x;
                int yTop = getPolygon().getBounds().y;

                return (x > xLeft - NEAR_DISTANCE && y > yTop - NEAR_DISTANCE
                                && x < xLeft + getBoundsWidth() + NEAR_DISTANCE && y < yTop
                                + getBoundsHeight() + NEAR_DISTANCE);
        }

        /**
         * Checks if this item is a frame title.
         * 
         * @return true if the item is a frame title
         */
        /*
         * public boolean isTitle() { // check if the title has been assigned if
         * (getID() >= 0 && this instanceof Text) if (getX() < 200 && getY() <
         * getSize() + system.io.KMSConversion.Y_ADJUST) return true; return false; }
         */

        public boolean isOldTag() {
                if (this instanceof Text)
                        if (((Text) this).getText().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(Graphics2D g);
        
        public void paintFill(Graphics2D g) {
                if (getFillColor() != null && getEnclosingDots() != null) {
                        g.setColor(getFillColor());
                        g.fillPolygon(getEnclosedShape());
                }
        }

        /**
         * 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 acitons.
         */
        public void performActions() {
                Frame sourceFrame = null;
                // 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) {
                        sourceFrame = DisplayIO.getCurrentFrame();
                }

                for (String s : getAction()) {
                        Actions.PerformAction(sourceFrame, this, s);
                }
        }

        /**
         * 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() {
                _lines.clear();
        }

        /**
         * Removes the given Constraint from the list of constraintss 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) {
                _lines.remove(line);
        }

        public void run() {
                try {
                        AgentStats.reset();
                        FrameGraphics
                                        .DisplayMessage("Running SimpleProgram...", Color.BLUE);
                        Simple.RunFrameAndReportError(this, new Context());
                        Simple.ProgramFinished();
                        FrameGraphics.DisplayMessage(AgentStats.getStats(), GREEN);
                } catch (ConcurrentModificationException ce) {
                        ce.printStackTrace();
                } catch (Exception e) {
                        FrameGraphics.LinkedErrorMessage(e.getMessage());
                        Simple.ProgramFinished();
                }
        }

        /**
         * Check if it has a relative link if so make it absolute.
         * 
         */
        public void setAbsoluteLink() {
                if (_link == null)
                        return;
                // Check if all the characters are digits and hence it is a relative
                // link
                for (int i = 0; i < _link.length(); i++) {
                        if (!Character.isDigit(_link.charAt(i)))
                                return;
                }

                // Make it an absolute link
                String framesetName;

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

                _link = framesetName + _link;
        }

        /**
         * Sets any action code (KMS action language) 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 setAction(List<String> actions) {
                if (actions == null || actions.size() == 0)
                        _actions = null;
                else
                        _actions = new LinkedList<String>(actions);
        }

        public void setActionCursorEnter(List<String> enter) {
                _actionCursorEnter = enter;
        }

        public void setActionCursorLeave(List<String> leave) {
                _actionCursorLeave = leave;
        }

        public void setActionEnterFrame(List<String> enter) {
                _actionEnterFrame = enter;
        }

        public void setActionLeaveFrame(List<String> leave) {
                _actionLeaveFrame = leave;
        }

        public void setActionMark(boolean val) {
                _actionMark = val;
        }

        /**
         * 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(int length, double ratio) {
                _arrowheadLength = length;
                _arrowheadRatio = ratio;
                updateArrowPolygon();
        }

        public void setArrowhead(Polygon arrow) {
                _arrowhead = arrow;
        }

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

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

        public void setBackgroundColor(Color c) {
                _colorBackground = c;
        }

        /**
         * 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(Color bottom) {
                _colorBottomShadow = bottom;
        }

        /**
         * Sets the foreground Color of this Item to the given Color.
         * 
         * @param c
         */
        public void setColor(Color c) {
                _color = c;
        }

        public void setConstraintIDs(String IDs) {
        }

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

        public void setData(String newData) {
                if (newData != null)
                        _data = new StringBuffer(newData);
                else
                        _data = 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;
        }

        public void setFillColor(Color c) {
                _colorFill = c;

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

        public void setFilledHighlight(boolean value) {
        }

        public void setFillPattern(String patternLink) {
                _fillPattern = patternLink;
        }

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

        public void setHighlight(boolean val) {
                _highlight = val;
        }

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

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

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

                for (Line line : getLines())
                        line.setLinePattern(pattern);
        }

        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 (FrameIO.isValidLink(frameName))
                        _link = frameName;
                else
                        FrameGraphics.ErrorMessage("[" + frameName
                                        + "] is not a valid frame name");
                // TODO make this throw exceptions etc...
        }

        public void setLinkFrameset(String frameset) {
                if (frameset == null || FrameIO.isValidFramesetName(frameset))
                        _link_frameset = frameset;
                else
                        FrameGraphics.ErrorMessage("[" + frameset
                                        + "] is not a valid frameset name");
                // TODO make this throw exceptions etc...
        }

        public void setLinkMark(boolean val) {
                _linkMark = val;
        }

        public void setLinkTemplate(String template) {
                if (FrameIO.isValidLink(template))
                        _link_template = template;
                else
                        FrameGraphics.ErrorMessage("[" + template
                                        + "] is not a valid frame name");
                // TODO make this throw exceptions etc...
        }

        /**
         * 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 setMaxSize(Dimension d) {
                if (d != null) {
                        _maxSize = d;
                        updatePolygon();
                }
        }

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

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

        public void setOwner(String own) {
                _owner = own;
        }

        public void setParent(Frame frame) {
                _parent = frame;
        }

        /**
         * Sets the position of this item on the screen
         * 
         * @param x
         *            The new X coordinate
         * @param y
         *            The new Y coordinate
         */
        public void setPosition(int x, int y) {
                _x = x;
                _y = y;

                updatePolygon();

                // 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 (!other.isFloating()) {
                                if (c.getType() == Constraint.HORIZONTAL) {
                                        if (other.getY() != y)
                                                other.setY(y);
                                }
                                if (c.getType() == Constraint.VERTICAL) {
                                        if (other.getX() != x)
                                                other.setX(x);
                                }
                        }
                }

                for (Line line : getLines())
                        line.updatePolygon();
        }

        public void setPosition(Point position) {
                setPosition(position.x, position.y);
        }

        public void setRelativeLink() {
                if (_link == null)
                        return;
                assert (_parent != null);
                // Check if the link is for the current frameset
                if (_parent.getFramesetName().equalsIgnoreCase(
                                Conversion.getFrameset(_link))) {
                        _link = "" + 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(int size) {
        }

        public void setThickness(float thick) {
                _thickness = thick;
                // update the size of any lines
                for (Line line : getLines())
                        line.setThickness(thick);
        }

        /**
         * 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() {
                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(Color top) {
                _colorTopShadow = top;
        }

        public void setWidth(int width) throws UnsupportedOperationException {
                throw new UnsupportedOperationException(
                                "Item type does not support width attribute!");
        }

        /**
         * 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(int newX) {
                setPosition(newX, getY());
        }

        /**
         * 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(int newY) {
                setPosition(getX(), newY);
        }

        /**
         * 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)
         */
        public int setSelectionColor() {
                return setSelectionColor(DEFAULT_HIGHLIGHT);
        }

        public int setSelectionColor(Color c) {
                _highlightThickness = DEFAULT_HIGHLIGHT_THICKNESS;
                if (c != null)
                        _highlightColor = c;
                else
                        _highlightColor = DEFAULT_HIGHLIGHT;

                return Item.UNCHANGED_CURSOR;
        }

        private void updateArrowPolygon() {
                if (getArrowheadLength() < 0 || getArrowheadRatio() < 0)
                        _arrowhead = null;
                else {
                        _arrowhead = new Polygon();
                        _arrowhead.addPoint((int) getX(), (int) getY());
                        _arrowhead
                                        .addPoint(
                                                        (int) getX() - getArrowheadLength(),
                                                        (int) (getY() - (getArrowheadLength() * getArrowheadRatio())));
                        _arrowhead.addPoint((int) getX(), (int) getY());
                        _arrowhead
                                        .addPoint(
                                                        (int) getX() - getArrowheadLength(),
                                                        (int) (getY() + (getArrowheadLength() * getArrowheadRatio())));
                }
        }

        protected abstract void updatePolygon();

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

        public boolean isVisible() {
                return _visible;
        }

        /**
         * 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
         * frames, or an overlay of a current frame.
         * 
         * @param e
         *            The event
         */
        public void onParentStateChanged(ItemParentStateChangedEvent e) {
        }

        public void setSelectedMode(SelectedMode mode, Color color) {
                setSelectionColor(color);
                _lastMode = _mode;
                _mode = mode;
        }

        public void restoreLastMode(Color selectionColor) {
                setSelectionColor(selectionColor);
                if (_mode != SelectedMode.None)
                        return;
                _mode = _lastMode;
                _lastMode = SelectedMode.None;
        }

        public SelectedMode getSelectedMode() {
                return _mode;
        }

        public void anchor() {
                Frame current = getParentOrCurrentFrame();
                setID(current.getNextItemID());
                setOffset(0, 0);
                setParent(current);

                current.addItem(this);
                current.setResort(true);
                setRelativeLink();
                setFloating(false);
        }

        /**
         * 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 DisplayIO.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) {
                _enclosure = enclosed;
        }

        /**
         * 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 Polygon getEnclosedShape() {
                if (_enclosure == null)
                        return null;

                Polygon poly = new Polygon();
                for (Item d : _enclosure) {
                        poly.addPoint(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;
        }

        public boolean isLineEnd() {
                return _lines.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(Color 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 offScreen() {
                Rectangle itemRect = getArea().getBounds();
                // Check that the bottom right corner of this item is on the screen
                if (itemRect.x + itemRect.width >= 0
                                && itemRect.y + itemRect.height >= 0)
                        return false;
                // Check if all the items it is connected to are offscreen
                for (Item i : getAllConnected()) {
                        Rectangle iRect = i.getArea().getBounds();
                        // Check that the bottom right corner of this item is on the screen
                        if (iRect.x + iRect.width >= 0 && iRect.y + iRect.height >= 0) {
                                return false;
                        }
                }
                return true;
        }

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

        public boolean isConnectedToAnnotation() {
                return _connectedToAnnotation;
        }
}