Changeset 1102 for trunk/src/org/expeditee/items/Item.java

Timestamp:

05/10/18 16:04:51 (6 years ago)

Author:

davidb

Message:

Reworking of the code-base to separate logic from graphics. This version of Expeditee now supports a JFX graphics as an alternative to SWING

File:

• trunk/src/org/expeditee/items/Item.java (modified) (109 diffs)

trunk/src/org/expeditee/items/Item.java

@@ -19 +19 @@
 package org.expeditee.items;
 
-import java.awt.BasicStroke;
-import java.awt.Color;
-import java.awt.Cursor;
-import java.awt.GradientPaint;
-import java.awt.Graphics2D;
-import java.awt.Point;
-import java.awt.Polygon;
-import java.awt.Rectangle;
-import java.awt.Shape;
-import java.awt.Stroke;
-import java.awt.geom.AffineTransform;
-import java.awt.geom.Area;
-import java.awt.geom.Point2D;
-import java.awt.geom.Rectangle2D;
 import java.util.ArrayList;
 import java.util.Collection;
@@ -46 +32 @@
 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.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.gio.EcosystemManager;
+import org.expeditee.gio.GraphicsManager;
+import org.expeditee.gio.gesture.StandardGestureActions;
 import org.expeditee.gui.AttributeValuePair;
-import org.expeditee.gui.DisplayIO;
+import org.expeditee.gui.DisplayController;
 import org.expeditee.gui.Frame;
 import org.expeditee.gui.FrameGraphics;
 import org.expeditee.gui.FrameIO;
-import org.expeditee.gui.FrameKeyboardActions;
-import org.expeditee.gui.FrameMouseActions;
 import org.expeditee.gui.FrameUtils;
 import org.expeditee.gui.FreeItems;
@@ -75 +74 @@
 public abstract class Item implements Comparable<Item>, Runnable {
 
-        public static final Float DEFAULT_THICKNESS = 2f;
-
-        public static final Float MINIMUM_THICKNESS = 0f;
-
-        public static final Float MINIMUM_PAINT_THICKNESS = 1f;
-
-        protected final int JOIN = BasicStroke.JOIN_ROUND;
-
-        protected final int CAP = BasicStroke.CAP_BUTT;
-
-        protected final Stroke DOT_STROKE = new BasicStroke(DEFAULT_THICKNESS,
-                        CAP, JOIN, 4.0F);
-
-        protected final Stroke HIGHLIGHT_STROKE = new BasicStroke(
-                        MINIMUM_THICKNESS, CAP, JOIN, 4.0F);
-
-        // contains all dots (including this one) that form an enclosure
-        // if this dot is part of an enclosing shape
-        private Collection<Item> _enclosure = null;
-
-        public static final int LEFT_MARGIN = 13;
-
-        // indicates which end the arrowhead should be drawn at
-        protected Polygon _poly = null;
-
-        protected boolean _connectedToAnnotation = false;
-
-        protected boolean _save = true;
-
-        private int _gradientAngle = 0;
-
-        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 ALTERNATE_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 = Color.white;
-
-        public static final Color TRANSPARENT = new Color(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 Color GREEN = Color.GREEN.darker();
-
-        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;
-
-        // The default value for integer attributes
-        public static final int DEFAULT_INTEGER = -1;
-
-        protected DotType _type = DotType.square;
-
-        protected boolean _filled = true;
-        
-        private Tooltip _tooltip = new Tooltip();
-
+        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 void DuplicateItem(Item source, Item dest) {
-                dest.setX(source.getX());
-                dest.setY(source.getY());
-
-                dest.setActions(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.setBorderColor(source.getBorderColor());
-
-                dest.setTooltips(source.getTooltip());
-                dest.setData(source.getData());
-                dest.setTag(source.getTag());
-                dest.setFillColor(source.getFillColor());
-                dest.setGradientColor(source.getGradientColor());
-                dest.setGradientAngle(source.getGradientAngle());
-                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.setMaxWidth(source.getMaxWidth());
-
-                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(), source.getArrowheadNibPerc());
-
-                dest.setDotType(source.getDotType());
-                dest.setFilled(source.getFilled());
+        
+        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 PermissionPair _permissionPair = 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 List<String> _data = 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;
+
+        protected DotType _type = DotType.square;
+
+        protected boolean _filled = true;
+
+        /** 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.setMaxWidth(this.getMaxWidth());
+
+                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 = source._anchorLeft;
-                // dest._anchorRight = source._anchorRight;
-                // dest._anchorTop = source._anchorTop;
-                // dest._anchorBottom = source._anchorBottom;
-                dest.setFormula(source.getFormula());
-                dest._overlay = source._overlay;
-                dest._mode = source._mode;// SelectedMode.None;
-                // dest._highlightColor = source._highlightColor;
-                // dest.setHighlight(source.getHighlight());
-
-                dest._visible = source._visible;
-
-                Frame parent = DisplayIO.getCurrentFrame();
-                if (parent == null)
-                        parent = source.getParentOrCurrentFrame();
+                // 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);
 
@@ -246 +397 @@
                 }
         }
-
-        public void setGradientAngle(int gradientAngle) {
+        
+        public void setDotType(DotType type) {
+                invalidateAll();
+                _type = type;
+                invalidateAll();
+        }
+
+        public DotType getDotType() {
+                return _type;
+        }
+
+        
+        public void setFilled(boolean filled)
+        {
+                invalidateAll();
+                _filled = filled;
+                invalidateAll();
+        }
+
+        public boolean getFilled() {
+                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);
+                        if (other.getGradientAngle() != gradientAngle) other.setGradientAngle(gradientAngle);
                 }
 
@@ -260 +438 @@
         }
 
-        public int getGradientAngle() {
+        /**
+         * Gets the angle of colour change for gradient fills.
+         * 
+         * @return The angle of colour change.
+         */
+        public double getGradientAngle() {
                 return _gradientAngle;
         }
 
-        public int getGravity() {
-                if (isVectorItem()) {
-                        return 2;
-                }
+        /**
+         * 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();
         }
 
-        public static boolean showLineHighlight() {
+        /**
+         * 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();
         }
 
-        public enum HighlightMode {
-                None, Enclosed, Connected, Disconnect, Normal
-        }
-
-        public void setHighlightMode(HighlightMode mode) {
-                setHighlightMode(mode, DEFAULT_HIGHLIGHT);
-        }
-
-        protected Float _anchorLeft = null;
-        protected Float _anchorRight = null;
-
-        protected Float _anchorTop = null;
-        protected Float _anchorBottom = null;
-
-        protected HighlightMode _mode = 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;
-
-        private boolean _linkMark = true;
-
-        private boolean _actionMark = true;
-
-        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 PermissionPair _permissionPair = null;
-        
-        private UserAppliedPermission _overlayPermission = null;
-        
-        public void setOverlayPermission(UserAppliedPermission overlayPermission) {
+        /**
+         * 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(PermissionPair permissionPair) {
+        public void setPermission(PermissionPair permissionPair)
+        {
                 _permissionPair = permissionPair;
         }
@@ -354 +512 @@
         }
 
-        // A fill color of null represents transparent
-        private Color _colorFill = null;
-
-        // A gradient color of null represents NO gradient
-        private Color _colorGradient = null;
-
-        // A fore color of null represents the default color
-        private Color _color = null;
-
-        protected Color _highlightColor = DEFAULT_HIGHLIGHT;
-
-        private Color _colorBackground = null;
-
-        private Color _colorBorder = 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;
-        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 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 List<String> _actions = null;
-
-        private List<String> _data = 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 Item() {
                 _creationDate = Formatter.getLongDateTime();
@@ -427 +520 @@
          * 
          * @param action
-         *            The action to add to this Item
-         */
-        public void addAction(String action) {
-                if (action == null || action.equals("")) {
-                        return;
-                }
+         *            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) {
-                        _poly = null;
+                        invalidateBounds();
                         invalidateCommonTrait(ItemAppearence.LinkChanged);
                 }
         }
 
-        public void addAllConnected(Collection<Item> connected) {
-                if (!connected.contains(this))
-                        connected.add(this);
+        public void addAllConnected(Collection<Item> connected)
+        {
+                if (!connected.contains(this)) connected.add(this);
 
                 for (Item item : getConnected()) {
-                        if (!connected.contains(item))
+                        if (!connected.contains(item)) {
                                 item.addAllConnected(connected);
+                        }
                 }
         }
@@ -460 +555 @@
          *            The Constraint to set this Dot as a member of.
          */
-        public void addConstraint(Constraint c) {
+        public void addConstraint(Constraint c)
+        {
                 // do not add duplicate constraint
                 if (_constraints.contains(c))
@@ -474 +570 @@
          *            The Line that this Point is an end of.
          */
-        public void addLine(Line line) {
+        public void addLine(Line line)
+        {
                 if (_lines.contains(line)) {
                         return;
@@ -490 +587 @@
          *         less than, equal to, or greater than the specified object.
          */
-        public int compareTo(Item i) {
+        public int compareTo(Item i)
+        {
                 return getY() - i.getY();
         }
@@ -499 +597 @@
          * the area and false otherwise.
          * 
-         * @param x
-         *            The x coordinate to check
-         * @param y
-         *            The y coordinate to check
+         * @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(int x, int y) {
-                return getPolygon().contains(x, y);
+        public boolean contains(Point p)
+        {
+                return getBounds().contains(p);
         }
 
@@ -518 +615 @@
         public abstract Item copy();
 
-        public void delete() {
+        public void delete()
+        {
                 _deleted = true;
         }
 
         @Override
-        public boolean equals(Object o) {
+        public boolean equals(Object o)
+        {
                 if (o == null)
                         return false;
@@ -542 +641 @@
          *         has been assigned.
          */
-        public List<String> getAction() {
+        public List<String> getAction()
+        {
                 return _actions;
         }
 
-        public List<String> getData() {
+        public List<String> getData()
+        {
                 return _data;
         }
 
-        public List<String> getActionCursorEnter() {
+        public List<String> getActionCursorEnter()
+        {
                 return _actionCursorEnter;
         }
 
-        public List<String> getActionCursorLeave() {
+        public List<String> getActionCursorLeave()
+        {
                 return _actionCursorLeave;
         }
 
-        public List<String> getActionEnterFrame() {
+        public List<String> getActionEnterFrame()
+        {
                 return _actionEnterFrame;
         }
 
-        public List<String> getActionLeaveFrame() {
+        public List<String> getActionLeaveFrame()
+        {
                 return _actionLeaveFrame;
         };
 
-        public boolean getActionMark() {
+        public boolean getActionMark()
+        {
                 return _actionMark;
         }
@@ -576 +682 @@
          * @return
          */
-        public Collection<Item> getAllConnected() {
+        public Collection<Item> getAllConnected()
+        {
                 Collection<Item> list = new LinkedHashSet<Item>();
                 addAllConnected(list);
@@ -582 +689 @@
         }
 
-        public Area getArea() {
+/*      public Area getArea() {
                 return new Area(getPolygon());
-        }
-
-        public String getArrow() {
+        }*/
+
+        public String getArrow()
+        {
                 if (!hasVisibleArrow())
                         return null;
@@ -597 +705 @@
         }
 
-        public Polygon getArrowhead() {
+        public PolygonBounds getArrowhead()
+        {
                 return _arrowhead;
         }
 
-        public float getArrowheadLength() {
+        public float getArrowheadLength()
+        {
                 return _arrowheadLength;
         }
 
-        public double getArrowheadRatio() {
+        public double getArrowheadRatio()
+        {
                 return _arrowheadRatio;
         }
 
-        public double getArrowheadNibPerc() {
+        public double getArrowheadNibPerc()
+        {
                 return _arrowheadNibPerc;
         }
         
-        public Color getBackgroundColor() {
-                return _colorBackground;
-        }
-
-        public Color getBorderColor() {
+        public Colour getBackgroundColor()
+        {
+                return _backgroundColour;
+        }
+
+        public Colour getBorderColor()
+        {
                 return _colorBorder;
         }
@@ -628 +742 @@
          *         border.
          */
-        public Color getBottomShadowColor() {
+        public Colour getBottomShadowColor()
+        {
                 return _colorBottomShadow;
         }
@@ -638 +753 @@
          *         returned by getArea().
          */
-        public int getBoundsHeight() {
-                return getPolygon().getBounds().height;
+        public int getBoundsHeight()
+        {
+                return AxisAlignedBoxBounds.getEnclosing(getBounds()).getHeight();
         }
 
@@ -648 +764 @@
          *         by getArea().
          */
-        public int getBoundsWidth() {
-                return getPolygon().getBounds().width;
-        }
-
-        // TODO draw the link with a circle rather than a polygon!!
-        public Polygon getLinkPoly() {
-                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 = getLinkPoly().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() {
+        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()
+        {
+                return _foregroundColour;
+        }
+
+        public Collection<Item> getConnected()
+        {
                 List<Item> conn = new LinkedList<Item>();
                 conn.add(this);
@@ -711 +818 @@
         }
 
-        public String getConstraintIDs() {
+        public String getConstraintIDs()
+        {
                 if (_constraints == null || _constraints.size() == 0)
                         return null;
@@ -732 +840 @@
          * @return a List of Constraints that this Dot is a member of.
          */
-        public List<Constraint> getConstraints() {
+        public List<Constraint> getConstraints()
+        {
                 return _constraints;
         }
 
-        public String getTag() {
+        public String getTag()
+        {
                 if (_tag != null && _tag.length() > 0)
                         return _tag.toString();
@@ -742 +852 @@
         }
 
-        public String getDateCreated() {
+        public String getDateCreated()
+        {
                 return _creationDate;
         }
 
-        public Color getFillColor() {
-                return _colorFill;
-        }
-
-        public String getFillPattern() {
+        public Colour getFillColor()
+        {
+                return _fillColour;
+        }
+
+        public String getFillPattern()
+        {
                 return _fillPattern;
         }
 
-        public String getFirstAction() {
+        public String getFirstAction()
+        {
                 if (_actions == null || _actions.size() == 0)
                         return null;
@@ -760 +874 @@
         }
 
-        public boolean getHighlight() {
+        /**
+         * Gets the value of <code>_highlight</code> for this item.
+         * TODO: Appears unused? cts16.
+         * 
+         * @return The value of <code>_highlight</code>.
+         */
+        public boolean getHighlight()
+        {
                 return _highlight;
         }
 
-        public Color getHighlightColor() {
-                if (_highlightColor.equals(getPaintColor()))
-                        return getAlternateHighlightColor();
+        public Colour getHighlightColor()
+        {
+                if (_highlightColour.equals(getPaintColor())) return getAlternateHighlightColor();
+                
                 return getDefaultHighlightColor();
         }
@@ -774 +896 @@
          * 
          * @return The ID of this Item.
-         */
-        public int getID() {
+         * 
+         * TODO: What does it mean to have a negative ID# (as used in TDFC)? cts16
+         */
+        public int getID()
+        {
                 return _id;
         }
@@ -784 +909 @@
          * @return The list of Line IDs that this point is part of.
          */
-        public String getLineIDs() {
+        public String getLineIDs()
+        {
                 String lineID = null;
 
@@ -797 +923 @@
         }
 
-        public int[] getLinePattern() {
+        public int[] getLinePattern()
+        {
                 return _linePattern;
         }
@@ -807 +934 @@
          *         Lines have been added.
          */
-        public List<Line> getLines() {
+        public List<Line> getLines()
+        {
                 return _lines;
         }
@@ -818 +946 @@
          *         this Item does not link to anything.
          */
-        public String getLink() {
+        public String getLink()
+        {
                 return _link;
         }
 
-        public String getFormula() {
+        public String getFormula()
+        {
                 return _formula;
         }
 
-        public boolean hasFormula() {
+        public boolean hasFormula()
+        {
                 return _formula != null;
         }
 
-        public boolean hasAttributeValuePair() {
+        public boolean hasAttributeValuePair()
+        {
                 return _attributeValuePair != null && _attributeValuePair.hasPair();
         }
 
-        public void setFormula(String formula) {
+        public void setFormula(String formula)
+        {
                 _formula = formula;
         }
 
-        public boolean calculate(String formula) {
+        public boolean calculate(String formula)
+        {
                 setFormula(formula);
                 return true;
         }
 
-        public String getLinkFrameset() {
+        public String getLinkFrameset()
+        {
                 return _link_frameset;
         }
 
-        public boolean getLinkMark() {
+        public boolean getLinkMark()
+        {
                 return _linkMark;
         }
 
-        public String getLinkTemplate() {
+        public String getLinkTemplate()
+        {
                 return _link_template;
         }
 
-        // public int getMaxWidth() {
+        // public int getMaxWidth()
+        // {
         // return _maxWidth;
         // }
 
-        public Point getOffset() {
+        public Point getOffset()
+        {
                 return _offset;
         }
 
-        public String getOwner() {
+        public String getOwner()
+        {
                 return _owner;
         }
 
-        public Color getPaintBackgroundColor() {
-                Color colorBackground = getBackgroundColor();
+        public Colour getPaintBackgroundColor()
+        {
+                Colour colorBackground = getBackgroundColor();
                 if (colorBackground == null) {
                         if (getParent() != null && getParent().getBackgroundColor() != null)
@@ -884 +1025 @@
          * @return The Color of this item (foreground)
          */
-        public final Color getPaintColor() {
+        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
-                Color color = getColor();
+                Colour color = getColor();
 
                 if (color == null) {
@@ -893 +1035 @@
                                 return getParent().getPaintForegroundColor();
 
-                        Frame current = DisplayIO.getCurrentFrame();
+                        Frame current = DisplayController.getCurrentFrame();
                         if (current == null) {
                                 return DEFAULT_FOREGROUND;
@@ -903 +1045 @@
         }
 
-        public final Color getPaintBorderColor() {
+        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
-                Color color = getBorderColor();
+                Colour color = getBorderColor();
 
                 if (color == null) {
@@ -912 +1055 @@
                                 return getParent().getPaintForegroundColor();
 
-                        Frame current = DisplayIO.getCurrentFrame();
+                        Frame current = DisplayController.getCurrentFrame();
                         if (current == null) {
                                 return DEFAULT_FOREGROUND;
@@ -922 +1065 @@
         }
 
-        protected Color getPaintHighlightColor() {
-                Color highlightColor = getDefaultHighlightColor();
+        protected Colour getPaintHighlightColor()
+        {
+                Colour highlightColor = getDefaultHighlightColor();
                 if (hasVisibleBorder()) {
                         if (getPaintBorderColor().equals(highlightColor)) {
@@ -931 +1075 @@
                         highlightColor = getDefaultHighlightColor();
                 }
-                if (getParent() != null
-                                && getParent().getPaintBackgroundColor().equals(highlightColor))
+                
+                if (getParent() != null && getParent().getPaintBackgroundColor().equals(highlightColor)) {
                         highlightColor = getParent().getPaintForegroundColor();
+                }
 
                 if (hasVisibleBorder()) {
-                        if (highlightColor.equals(getBorderColor())
-                                        && getThickness() == getHighlightThickness()) {
-                                highlightColor = new Color(highlightColor.getRed(),
-                                                highlightColor.getGreen(), highlightColor.getBlue(),
-                                                150);
+                        if (highlightColor.equals(getBorderColor()) && getThickness() == getHighlightThickness()) {
+                                highlightColor = highlightColor.clone();
+                                highlightColor.setAlpha(Colour.FromComponent255(150));
                         }
                 }
@@ -947 +1090 @@
         }
 
-        static final int BRIGHTNESS = 185;
-
-        protected Color getDefaultHighlightColor() {
-                if (isVectorItem()
-                                && !this.contains(FrameMouseActions.getX(), FrameMouseActions
-                                                .getY())) {
-                        return new Color(255, BRIGHTNESS, BRIGHTNESS);
-                }
-                return _highlightColor;
-        }
-
-        protected Color getAlternateHighlightColor() {
-                if (isVectorItem()
-                                && !this.contains(FrameMouseActions.getX(), FrameMouseActions
-                                                .getY())) {
-                        return new Color(BRIGHTNESS, BRIGHTNESS, 255);
+        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;
+        protected int getHighlightThickness()
+        {
+                if (isVectorItem()) return _vectorHighlightThickness;
+                
                 return _highlightThickness;
         }
 
-        public final Frame getParent() {
+        public final Frame getParent()
+        {
                 return _parent;
         }
 
-        public final Point getPosition() {
+        /** Gets the position of this item. */
+        public final Point getPosition()
+        {
                 return new Point(getX(), getY());
         }
@@ -987 +1130 @@
          * @return The size of this Item.
          */
-        public float getSize() {
-                return -1.0F;
+        public float getSize()
+        {
+                return SIZE_NOT_APPLICABLE;
         }
 
@@ -997 +1141 @@
          * @return The Color displayed on the top\left half of this Item's border.
          */
-        public Color getTopShadowColor() {
+        public Colour getTopShadowColor()
+        {
                 return _colorTopShadow;
         }
 
-        public String getTypeAndID() {
+        public String getTypeAndID()
+        {
                 return "T " + getID();
         }
 
-        public Integer getWidthToSave() {
+        public Integer getWidthToSave()
+        {
                 return getWidth();
         }
 
-        public Integer getWidth() {
+        public Integer getWidth()
+        {
                 return null;
         }
 
-        public int getHeight() {
+        public int getHeight()
+        {
                 return 0;
         }
@@ -1022 +1171 @@
          * @return The X coordinate of this Item on the screen
          */
-        public int getX() {
+        public int getX()
+        {
                 return Math.round(_x);
         }
@@ -1031 +1181 @@
          * @return The Y coordinate of this Item on the screen
          */
-        public int getY() {
+        public int getY()
+        {
                 return Math.round(_y);
         }
 
-        public boolean hasVisibleArrow() {
+        public boolean hasVisibleArrow()
+        {
                 return isLineEnd() && getArrowheadRatio() != 0 && getArrowheadLength() != 0;
         }
@@ -1046 +1198 @@
          * @return True if the two Shapes overlap, False otherwise.
          */
-        public boolean intersects(Polygon p) {
-                if (p == null)
-                        return false;
-
-                Area a = new Area(p);
-                Area thisArea = this.getArea();
+        public boolean intersects(PolygonBounds otherBounds)
+        {
+                if (otherBounds == null) return false;
+                
+                Bounds thisBounds = getBounds();
+                
                 // Need to do this check for circles
-                if (a.equals(thisArea))
-                        return true;
-
-                a.intersect(thisArea);
+                if (otherBounds.equals(thisBounds)) return true;
+
+                return otherBounds.intersects(thisBounds);
 
                 // Need to check the second equality so that we dont pick up circles
                 // inside other circles
-                return !a.isEmpty() && !a.equals(new Area(p));
+                //return !a.isEmpty() && !a.equals(new Area(p));
         }
 
@@ -1069 +1220 @@
          * @return True if this Item is an annotation, False otherwise.
          */
-        public boolean isAnnotation() {
+        public boolean isAnnotation()
+        {
                 return false;
         }
 
-        public boolean isFloating() {
+        public boolean isFloating()
+        {
                 return _floating;
         }
 
-        public boolean isFrameName() {
+        public boolean isFrameName()
+        {
                 if (this.getParent() == null || this.getParent().getNameItem() != this)
                         return false;
@@ -1083 +1237 @@
         }
 
-        public boolean isFrameTitle() {
+        public boolean isFrameTitle()
+        {
                 if (this.getParent() == null || this.getParent().getTitleItem() != this)
                         return false;
@@ -1095 +1250 @@
          *         otherwise.
          */
-        public boolean isHighlighted() {
+        public boolean isHighlighted()
+        {
                 if (isFloating())
                         return false;
-                return _mode != HighlightMode.None;
+                return _highlightMode != HighlightMode.None;
         }
 
@@ -1109 +1265 @@
          * @return True if the given framename is proper, false otherwise.
          */
-        public boolean isLinkValid() {
+        public boolean isLinkValid()
+        {
                 if (FrameIO.isPositiveInteger(getLink()))
                         return true;
@@ -1118 +1275 @@
         }
 
-        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);
-        }
-
-        public boolean isOldTag() {
+        /**
+         * 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"))
@@ -1153 +1321 @@
          *            The Graphics to draw this Item on.
          */
-        public abstract void paint(Graphics2D g);
-        
-        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) {
+        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);
@@ -1166 +1339 @@
         }
         
-        public List<String> getTooltip() {
+        public List<String> getTooltip()
+        {
                 return _tooltip.asStringList();
         }
         
-        public Collection<Text> getTooltipItems() {
+        public Collection<Text> getTooltipItems()
+        {
                 return _tooltip.getTooltips();
         }
 
-        public void clearTooltips() {
+        public void clearTooltips()
+        {
                 final Frame frame = this.getParent();
-                if(_tooltip != null)
+                if(_tooltip != null) {
                         for(final Text tooltip: _tooltip.getTooltips()) frame.removeItem(tooltip);
-        }
-        
-        public void paintTooltip(final Graphics2D g) {
-                final Rectangle bounds = this.getPolygon().getBounds();
-                int x = bounds.x + bounds.width;
-                if(x + _tooltip.getWidth() > FrameGraphics.getMaxFrameSize().width) {
-                        x -= x + _tooltip.getWidth() - FrameGraphics.getMaxFrameSize().width;
-                }
-                int y = bounds.y + bounds.height;
-                if(y + _tooltip.getCollectiveHeight() > FrameGraphics.getMaxFrameSize().height) {
-                        y = bounds.y + bounds.height / 2 - _tooltip.getCollectiveHeight();
-                }
+                }
+        }
+        
+        public void paintTooltip()
+        {
+                final Bounds bounds = AxisAlignedBoxBounds.getEnclosing(this.getBoundingBox());
+                Dimension frameSize = DisplayController.getFramePaintArea().getSize();
+                
+                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(g);
+                        tooltip.paint();
                         y += tooltip.getHeight();
                 }
         }
         
-        public void paintFill(Graphics2D g) {
-                Color fillColor = getFillColor();
+        public void paintFill() {
+                Colour fillColor = getFillColor();
                 if (fillColor != null && getEnclosingDots() != null) {
-                        setFillPaint(g);
-                        g.fillPolygon(getEnclosedShape());
-                }
-        }
-
-        protected void setFillPaint(Graphics2D g) {
-                Color fillColor = getFillColor();
+                        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!!
-                        fillColor = new Color(fillColor.getRed(), fillColor.getGreen(),
-                                        fillColor.getBlue(), fillColor.getAlpha());
-                }
-                g.setColor(fillColor);
-                Color gradientColor = getGradientColor();
-                if (gradientColor != null) {
+                        // 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...
                          */
-                        Shape s = getEnclosedShape();
-                        if (s != null) {
-                                Rectangle b = s.getBounds();
-                                double rads = getGradientAngle() * Math.PI / 180;
-                                double cos = Math.cos(rads);
-                                double sin = Math.sin(rads);
-
-                                GradientPaint gp = new GradientPaint((int) (b.x + b.width
-                                                * (0.2 * cos + 0.5)), (int) (b.y + b.height
-                                                * (0.2 * sin + 0.5)), fillColor, (int) (b.x + b.width
-                                                * (-0.8 * cos + 0.5)), (int) (b.y + b.height
-                                                * (-0.8 * sin + 0.5)), gradientColor);
-                                g.setPaint(gp);
-                        }
-                }
+                        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 acitons.
+         * link as well the link is used as the source frame for all actions.
          */
         public void performActions() {
@@ -1268 +1454 @@
                         // For actions like format they rely on this being set to the
                         // current frame incase the item being activated is on an overlay
-                        sourceFrame = DisplayIO.getCurrentFrame();
+                        sourceFrame = DisplayController.getCurrentFrame();
                 }
 
@@ -1388 +1574 @@
                         MessageBay.displayMessage("See SIMPLE doc for ["
                                         + ise.getStatement() + "] statement", ise.getStatement()
-                                        + "1", Color.CYAN.darker(), true, null);
+                                        + "1", Colour.CYAN.darker(), true, null);
                 } catch (Exception e) {
                         MessageBay.linkedErrorMessage(e.getMessage());
@@ -1394 +1580 @@
                 Simple.ProgramFinished();
                 // Need to repaint any highlights etc
-                FrameGraphics.requestRefresh(true);
+                DisplayController.requestRefresh(true);
         }
 
@@ -1414 +1600 @@
 
                 if (_parent == null)
-                        framesetName = DisplayIO.getCurrentFrame().getFramesetName();
+                        framesetName = DisplayController.getCurrentFrame().getFramesetName();
                 else
                         framesetName = _parent.getFramesetName();
@@ -1428 +1614 @@
          *            The lines of code to associate with this Item
          */
-        public void setActions(List<String> actions) {
+        public void setActions(List<String> actions)
+        {
                 if (actions == null || actions.size() == 0) {
                         invalidateCommonTrait(ItemAppearence.LinkChanged);
                         _actions = null;
-                } else
+                } else {
                         _actions = new LinkedList<String>(actions);
-
-                // Want to resize the highlight box for text items if actions have been
-                // added
-                _poly = null;
+                }
+                
+                // Want to resize the highlight box for text items if actions have been added
+                invalidateBounds();
                 invalidateCommonTrait(ItemAppearence.LinkChanged);
         }
@@ -1481 +1668 @@
         }
 
-        public void setActionMark(boolean val) {
-                if (!val)
-                        invalidateCommonTrait(ItemAppearence.LinkChanged);
-                _poly = null;
+        public void setActionMark(boolean val)
+        {
+                if (!val) invalidateCommonTrait(ItemAppearence.LinkChanged);
+                invalidateBounds();
                 _actionMark = val;
-                if (val)
-                        invalidateCommonTrait(ItemAppearence.LinkChanged);
+                if (val) invalidateCommonTrait(ItemAppearence.LinkChanged);
         }
 
@@ -1519 +1705 @@
         }
         
-        public void setArrowhead(Polygon arrow) {
+        public void setArrowhead(PolygonBounds arrow) {
                 _arrowhead = arrow;
         }
@@ -1538 +1724 @@
         }
 
-        public void setBackgroundColor(Color c) {
-                if (c != _colorBackground) {
-                        _colorBackground = c;
+        public void setBackgroundColor(Colour c) {
+                if (c != _backgroundColour) {
+                        _backgroundColour = c;
                         invalidateCommonTrait(ItemAppearence.BackgroundColorChanged);
                 }
         }
 
-        public void setBorderColor(Color c) {
+        public void setBorderColor(Colour c) {
                 if (c != _colorBorder) {
                         _colorBorder = c;
@@ -1560 +1746 @@
          *            Item's border.
          */
-        public void setBottomShadowColor(Color bottom) {
+        public void setBottomShadowColor(Colour bottom) {
                 _colorBottomShadow = bottom;
         }
@@ -1569 +1755 @@
          * @param c
          */
-        public void setColor(Color c) {
-                if (c != _color) {
-                        _color = 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
-                                FrameKeyboardActions.Refresh();
+                                StandardGestureActions.Refresh();
                         }
                 }
@@ -1605 +1791 @@
         }
 
-        public void setFillColor(Color c) {
-
-                _colorFill = c;
+        public void setFillColor(Colour c) {
+
+                _fillColour = c;
 
                 for (Line line : _lines) {
@@ -1620 +1806 @@
         }
 
-        public void setGradientColor(Color c) {
-                _colorGradient = c;
+        public void setGradientColor(Colour c)
+        {
+                _gradientColour = c;
 
                 for (Line line : _lines) {
@@ -1633 +1820 @@
         }
 
-        public Color getGradientColor() {
-                return _colorGradient;
+        public Colour getGradientColor() {
+                return _gradientColour;
         }
 
@@ -1647 +1834 @@
         }
 
+        /**
+         * 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;
@@ -1693 +1886 @@
          *            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 poly so the
+        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)
-                        _poly = null;
-
-                if (FrameIO.isValidLink(frameName))
+                if (frameName == null || getLink() == null) invalidateBounds();
+
+                if (FrameIO.isValidLink(frameName)) {
                         _link = frameName;
-                else
-                        MessageBay.errorMessage("[" + frameName
-                                        + "] is not a valid frame name");
+                } else {
+                        MessageBay.errorMessage("[" + frameName + "] is not a valid frame name");
+                }
                 // TODO make this throw exceptions etc...
 
@@ -1721 +1912 @@
         }
 
-        public void setLinkFrameset(String frameset) {
-                if (frameset == null || FrameIO.isValidFramesetName(frameset))
+        public void setLinkFrameset(String frameset)
+        {
+                if (frameset == null || FrameIO.isValidFramesetName(frameset)) {
                         _link_frameset = frameset;
-                else
-                        MessageBay.errorMessage("[" + frameset
-                                        + "] is not a valid frameset name");
+                } else {
+                        MessageBay.errorMessage("[" + frameset + "] is not a valid frameset name");
+                }
                 // TODO make this throw exceptions etc...
         }
 
-        public void setLinkMark(boolean val) {
-                if (!val)
-                        invalidateCommonTrait(ItemAppearence.LinkChanged);
-                _poly = null;
+        public void setLinkMark(boolean val)
+        {
+                if (!val) invalidateCommonTrait(ItemAppearence.LinkChanged);
+                invalidateBounds();
                 _linkMark = val;
-                if (val)
-                        invalidateCommonTrait(ItemAppearence.LinkChanged);
-        }
-
-        public void setLinkTemplate(String template) {
-                if (FrameIO.isValidLink(template))
+                if (val) invalidateCommonTrait(ItemAppearence.LinkChanged);
+        }
+
+        public void setLinkTemplate(String template)
+        {
+                if (FrameIO.isValidLink(template)) {
                         _link_template = template;
-                else
-                        MessageBay.errorMessage("[" + template
-                                        + "] is not a valid frame name");
+                } else {
+                        MessageBay.errorMessage("[" + template + "] is not a valid frame name");
+                }
                 // TODO make this throw exceptions etc...
         }
@@ -1763 +1955 @@
 
         public void setOffset(int x, int y) {
-                _offset.setLocation(x, y);
+                _offset.set(x, y);
         }
 
         public void setOffset(Point p) {
-                _offset.setLocation(p);
+                _offset.set(p);
         }
 
@@ -1805 +1997 @@
                         }
                 }
-                if (_colorFill != null) {
+                if (_fillColour != null) {
                         invalidateFill(); // only invalidates if has fill
                 }
@@ -1814 +2006 @@
         }
 
-        
-        
-        
-        
         protected void anchorConstraints()
         {
@@ -1830 +2018 @@
                                         if (isAnchoredY()) {
                                                 // Make the 'other' item have the same anchor top/bottom values as this
-                                                other._anchorTop    = _anchorTop;
-                                                other._anchorBottom = _anchorBottom;
+                                                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._anchorLeft  = _anchorLeft;
-                                                other._anchorRight = _anchorRight;
+                                                other._anchoring.setXAnchor(this._anchoring);
                                         }
                                 } else if (c.isDiagonal()) {
@@ -1855 +2041 @@
          *            The new Y coordinate
          */
-        public void setPosition(float x, float y) {
+        public void setPosition(float x, float y)
+        {
                 float deltaX = x - _x;
                 float deltaY = y - _y;
 
-                if (deltaX == 0 && deltaY == 0)
-                        return;
+                if (deltaX == 0 && deltaY == 0) return;
 
                 invalidateCommonTraitForAll(ItemAppearence.PreMoved);
@@ -1868 +2054 @@
 
                 for (Item i : getEnclosures()) {
-                        i.updatePolygon();
-                }
-                updatePolygon();
+                        i.invalidateBounds();
+                }
+                invalidateBounds();
 
                 // update the position of any dots that are constrained by this one
@@ -1951 +2137 @@
 
                 for (Line line : getLines()) {
-                        line.updatePolygon();
+                        line.invalidateBounds();
                 }
 
@@ -2007 +2193 @@
          *            their thickness set
          */
-        public void setThickness(float thick, boolean setConnectedThickness) {
-                if (thick == _thickness)
-                        return;
+        public void setThickness(float thick, boolean setConnectedThickness)
+        {
+                if (thick == _thickness) return;
+                
                 boolean bigger = thick > _thickness;
 
@@ -2015 +2202 @@
                         if (setConnectedThickness) {
                                 // TODO is there a more efficient way of doing this?
-                                for (Item i : getConnected())
-                                        i.invalidateCommonTrait(ItemAppearence.Thickness);
+                                for (Item i : getConnected()) i.invalidateCommonTrait(ItemAppearence.Thickness);
                         } else {
                                 invalidateCommonTrait(ItemAppearence.Thickness);
@@ -2028 +2214 @@
                  * etc...
                  */
-                for (Line line : getLines())
-                        line.setThickness(thick, setConnectedThickness);
-
-                if (setConnectedThickness)
-                        updatePolygon();
+                for (Line line : getLines()) line.setThickness(thick, setConnectedThickness);
+
+                if (setConnectedThickness) invalidateBounds();
 
                 if (bigger) {
                         if (setConnectedThickness) {
-                                for (Item i : getConnected())
-                                        i.invalidateCommonTrait(ItemAppearence.Thickness);
+                                for (Item i : getConnected()) i.invalidateCommonTrait(ItemAppearence.Thickness);
                         } else {
                                 invalidateCommonTrait(ItemAppearence.Thickness);
@@ -2050 +2233 @@
          *         set).
          */
-        public float getThickness() {
+        public float getThickness()
+        {
                 return _thickness;
         }
@@ -2062 +2246 @@
          *            Item's border.
          */
-        public void setTopShadowColor(Color top) {
+        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 setRightMargin(int i, boolean fixWidth) {
+        public void setWidth(Integer width) throws UnsupportedOperationException
+        {
+                throw new UnsupportedOperationException("Item type does not support width attribute!");
+        }
+
+        public void setRightMargin(int i, boolean fixWidth)
+        {
                 int newWidth = i - getX() - Item.MARGIN_LEFT;
+                if (newWidth < 0) newWidth = 0;
                 if (!fixWidth) {
                         newWidth *= -1;
@@ -2113 +2299 @@
          *         means no change)
          */
-        public int setHighlightColor() {
-                return setHighlightColor(DEFAULT_HIGHLIGHT);
-        }
-
-        public int setHighlightColor(Color c) {
+        
+        /**
+         * 
+         * 
+         * @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()) {
@@ -2128 +2322 @@
                 _highlightThickness = DEFAULT_HIGHLIGHT_THICKNESS;
 
-                Color selColor = (c != null) ? c : DEFAULT_HIGHLIGHT;
-                if (_highlightColor != c) {
-                        _highlightColor = selColor;
+                Colour selColor = (c != null) ? c : DEFAULT_HIGHLIGHT;
+                if (_highlightColour != c) {
+                        _highlightColour = selColor;
                         this.invalidateCommonTrait(ItemAppearence.HighlightColorChanged);
                 }
-
-                return Item.UNCHANGED_CURSOR;
 
         }
@@ -2146 +2338 @@
         }
 
-        public abstract void updatePolygon();
+        /** Returns a Bounds which represents the area covered by the item (including its gravity). */
+        public abstract Bounds updateBounds();
 
         public void setHidden(boolean state) {
@@ -2172 +2365 @@
         }
 
-        public void setHighlightMode(HighlightMode mode, Color color) {
-                setHighlightColor(color);
-                if (hasPermission(UserAppliedPermission.followLinks)
-                                || getEditTarget().hasPermission(UserAppliedPermission.followLinks)) {
-                        if (_mode != mode) {
-                                _mode = mode;
-                                this.invalidateCommonTrait(ItemAppearence.HighlightModeChanged);
-                        }
-                }
+        /**
+         * 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 _mode;
+                return _highlightMode;
         }
 
@@ -2191 +2385 @@
                 // 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) {
-                        int id = _id;
                         setID(current.getNextItemID());
-                        // System.out.println(this + " - Set ID to " + _id + " (was " + id + ")");
                 } else {
                         // System.out.println(this + " - Kept old ID of " + _id);
@@ -2239 +2431 @@
                 // if the item is from an overlay the parent will NOT be null
                 if (getParent() == null) {
-                        return DisplayIO.getCurrentFrame();
+                        return DisplayController.getCurrentFrame();
                 }
                 return getParent();
@@ -2275 +2467 @@
          *         the enclosed list.
          */
-        public Polygon getEnclosedShape() {
-                if (_enclosure == null)
-                        return null;
-
-                Polygon poly = new Polygon();
+        public PolygonBounds getEnclosedShape()
+        {
+                if (_enclosure == null) return null;
+
+                PolygonBounds poly = new PolygonBounds();
                 for (Item d : _enclosure) {
-                        poly.addPoint(d.getX(), d.getY());
+                        poly.addPoint(new Point(d.getX(), d.getY()));
                 }
 
@@ -2332 +2524 @@
          *            the new color for the line
          */
-        protected void lineColorChanged(Color c) {
+        protected void lineColorChanged(Colour c) {
                 for (Line l : getLines()) {
                         if (l.getColor() != c)
@@ -2345 +2537 @@
          */
         public boolean offScreenTopOrLeft() {
-                Rectangle itemRect = getArea().getBounds();
+                Bounds bounds = getBoundingBox();
+                
                 // Check that the bottom right corner of this item is on the screen
-                if (itemRect.x + itemRect.width >= 0
-                                && itemRect.y + itemRect.height >= 0)
+                if (bounds.getMaxX() >= 0 && bounds.getMaxY() >= 0) {
                         return false;
+                }
+                
                 // Check if all the items it is connected to are offscreen
                 for (Item i : getAllConnected()) {
-                        Rectangle iRect = i.getArea().getBounds();
+                        bounds = i.getBoundingBox();
                         // Check that the bottom right corner of this item is on the screen
-                        if (iRect.x + iRect.width >= 0 && iRect.y + iRect.height >= 0) {
+                        if (bounds.getMaxX() >= 0 && bounds.getMaxY() >= 0) {
                                 return false;
                         }
                 }
+                
                 return true;
         }
@@ -2374 +2569 @@
         }
 
-        public void setAction(String action) {
-                // Want to resize the highlight box for text items if actions are been
-                // added
+        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) {
-                        _poly = null;
+                        invalidateBounds();
                         _actions = new LinkedList<String>();
                 } else {
                         _actions.clear();
                 }
-                if (action != null && action.length() > 0)
-                        _actions.add(action);
+                
+                if (action != null && action.length() > 0) _actions.add(action);
+                
                 invalidateCommonTrait(ItemAppearence.LinkChanged);
         }
@@ -2395 +2592 @@
         }
 
-        protected Rectangle getLinkDrawArea() {
+        protected AxisAlignedBoxBounds getLinkDrawArea() {
                 return getLinkDrawArea(getX() - LEFT_MARGIN, getY() + getLinkYOffset());
         }
@@ -2410 +2607 @@
          * @return The drawing area of the link at the given coordinates.
          */
-        public Rectangle getLinkDrawArea(int x, int y) {
-                return new Rectangle(x + 2, y - 1, 8, 8);
+        public AxisAlignedBoxBounds getLinkDrawArea(int x, int y) {
+                return new AxisAlignedBoxBounds(x + 2, y - 1, 8, 8);
         }
 
@@ -2419 +2616 @@
          * @param g
          */
-        protected void paintLink(Graphics2D g) {
-                paintLinkGraphic(g, getX() - LEFT_MARGIN, getY() + getLinkYOffset());
+        protected void paintLink() {
+                paintLinkGraphic(getX() - LEFT_MARGIN, getY() + getLinkYOffset());
         }
 
@@ -2438 +2635 @@
          *            centered)
          */
-        public void paintLinkGraphic(Graphics2D g, int x, int y) {
-
-                boolean hasLink = getLink() != null;
+        public void paintLinkGraphic(int x, int y) {
+
+                boolean hasLink = hasLink();
                 boolean hasAction = hasAction();
 
                 if (hasLink || hasAction) {
-                        g.setStroke(HIGHLIGHT_STROKE);
+                        GraphicsManager g = EcosystemManager.getGraphicsManager();
+                        Fill fill = new Fill();
+                        Colour colour = null;
+                        Point offset = new Point(x, y);
+                        
                         if (hasLink && hasAction) {
-                                g.setColor(LINK_ACTION_COLOR);
+                                colour = LINK_ACTION_COLOR;
                         } else if (hasLink) {
-                                g.setColor(LINK_COLOR);
+                                colour = LINK_COLOR;
                         } else if (hasAction) {
-                                g.setColor(ACTION_COLOR);
+                                colour = ACTION_COLOR;
                         }
-
-                        AffineTransform at = new AffineTransform();
-                        AffineTransform orig = g.getTransform();
-                        at.translate(x, y);
-                        g.setTransform(at);
-
-                        if (getLinkMark() && getLink() != null) {
-                                g.drawPolygon(getLinkPoly());
-
+                        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());
+                                if (!isLinkValid()) {
+                                        g.drawPolygon(getCircleCross(), offset, null, 0.0f, null, colour, HIGHLIGHT_STROKE);
+                                }
                         }
 
-                        if (getActionMark() && hasAction()) {
-                                g.drawPolygon(getLinkPoly());
-                                g.fillPolygon(getLinkPoly());
+                        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.setColor(getParent().getPaintBackgroundColor());
-                                        g.drawPolygon(getCircleCross());
+                                        g.drawPolygon(getCircleCross(), offset, null, 0.0f, null, getParent().getPaintBackgroundColor(), HIGHLIGHT_STROKE);
                                 }
                         }
-
-                        // reset the graphics tranformation
-                        g.setTransform(orig);
+                        
+                        g.setAntialiasing(false);
                 }
         }
@@ -2539 +2737 @@
                         return null;
                 // assert (_parent!= null);
-                Frame parent = DisplayIO.getCurrentFrame();
+                Frame parent = DisplayController.getCurrentFrame();
                 assert (parent != null);
 
@@ -2587 +2785 @@
                 while (!lines.isEmpty()) {
                         Line l = lines.remove();
-                        // if we havnt visited the line yet visit it
+                        // 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 enexplored lines to our list
+                                // Add all the unexplored lines to our list
                                 while (!lines.isEmpty()) {
                                         l = lines.remove();
@@ -2613 +2811 @@
          *         is part of
          */
-        public double getEnclosedArea() {
-                if (_enclosure == null)
-                        return 0.0;
-                Rectangle2D box = getEnclosedShape().getBounds2D();
+        public double getEnclosedArea()
+        {
+                AxisAlignedBoxBounds box = getEnclosedBox();
+                if (box == null) return 0.0;
                 return box.getWidth() * box.getHeight();
         }
 
-        public Rectangle getEnclosedRectangle() {
-                if (_enclosure == null)
-                        return null;
-                return getEnclosedShape().getBounds();
-        }
-
-        public int getEnclosureID() {
+        /**
+         * 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 Shape that surrounds this Item representing this Item's
+         * Returns the Bounds that surrounds this Item representing this Item's
          * 'gravity'.
          * 
-         * @return The Shape (rectangle) surrounding this Item, which represents
+         * @return The Bounds surrounding this Item, which represents
          *         this Items 'gravity'.
          */
-        public final Polygon getPolygon() {
-                if (_poly == null)
-                        updatePolygon();
-
-                return new Polygon(_poly.xpoints, _poly.ypoints, _poly.npoints);
+        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;
+        }
+        
+        public final AxisAlignedBoxBounds getBoundingBox()
+        {
+                return AxisAlignedBoxBounds.getEnclosing(getBounds());
         }
 
@@ -2651 +2877 @@
          * @param ratio
          */
-        public void translate(Point2D origin, double 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()));
-                updatePolygon();
+                _x = (float) (origin.x + ratio * (_x - origin.x));
+                _y = (float) (origin.y + ratio * (_y - origin.y));
+                invalidateBounds();
                 for (Line line : getLines())
-                        line.updatePolygon();
+                        line.invalidateBounds();
 
                 invalidateCommonTraitForAll(ItemAppearence.PostMoved);
@@ -2698 +2924 @@
         }
 
-        Collection<XRayable> _enclosures = new HashSet<XRayable>();
-
-        private boolean _deleted = false;
-
-        private Overlay _overlay = null;
-
-        protected AttributeValuePair _attributeValuePair = null;
-
-        private Float _autoStamp = null;
-
         /**
          * For now there can only be one enclosure per item
@@ -2741 +2957 @@
          *         highlighting bounds
          */
-        public Rectangle[] getDrawingArea() {
-
-                return new Rectangle[] { ItemUtils.expandRectangle(getPolygon()
-                                .getBounds(), (int) Math.ceil(Math.max(_highlightThickness,
-                                getThickness()))) };
-
+        public AxisAlignedBoxBounds getDrawingArea() {
+
+                return ItemUtils.expandRectangle(
+                                        getBoundingBox(),
+                                        (int) Math.ceil(Math.max(_highlightThickness, getThickness())) + 1 // + 1 to make sure
+                );
         }
 
@@ -2754 +2970 @@
          * @return True if area intersects with this items drawing area.
          */
-        public final boolean isInDrawingArea(Area area) {
-                for (Rectangle r : getDrawingArea()) {
-                        if (area.intersects(r))
-                                return true;
-                }
-                return false;
-        }
-
-        /**
-         * Completetly invalidates the item - so that it should be redrawed. Note:
-         * This is handled internally, it should be reare to invoke this externally
-         */
-        public final void invalidateAll() {
+        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());
         }
@@ -2776 +2994 @@
          * @param damagedAreas
          */
-        protected final void invalidate(Rectangle[] damagedAreas) {
-                for (Rectangle r : damagedAreas)
-                        invalidate(r);
+        protected final void invalidate(Bounds[] damagedAreas)
+        {
+                if (damagedAreas != null) for (Bounds b : damagedAreas) invalidate(b);
         }
 
@@ -2787 +3005 @@
          * @param damagedAreas
          */
-        protected final void invalidate(Rectangle damagedArea) {
-                FrameGraphics.invalidateItem(this, damagedArea);
+        protected final void invalidate(Bounds damagedArea)
+        {
+                if (damagedArea != null) DisplayController.invalidateItem(this, damagedArea);
         }
 
@@ -2796 +3015 @@
          * @param trait
          */
-        public final void invalidateCommonTrait(ItemAppearence trait) {
+        public final void invalidateCommonTrait(ItemAppearence trait)
+        {
                 invalidate(getDamagedArea(trait));
 
-                if (_colorFill != null
-                                && (trait == ItemAppearence.Added || trait == ItemAppearence.Removed)) {
+                if (_fillColour != null && (trait == ItemAppearence.Added || trait == ItemAppearence.Removed)) {
                         invalidateFill();
                 }
@@ -2808 +3027 @@
          * Invalidates fill if has one, even if no color is set.
          */
-        public void invalidateFill() {
+        public void invalidateFill()
+        {
                 if (isLineEnd() && _enclosure != null) {
-                        invalidate(getEnclosedShape().getBounds());
+                        invalidate(getEnclosedBox());
                 }
         }
@@ -2826 +3046 @@
          * @return The damaged area according to the visual trait that has changed.
          */
-        protected Rectangle[] getDamagedArea(ItemAppearence trait) {
-
+        protected AxisAlignedBoxBounds getDamagedArea(ItemAppearence trait)
+        {
                 if (trait == ItemAppearence.LinkChanged)
-                        return new Rectangle[] { getLinkDrawArea() }; // Invalidate area
-                // where link is
-                // drawn
+                        return getLinkDrawArea(); // Invalidate area where link is drawn
 
                 return getDrawingArea();
-
         }
 
@@ -2864 +3081 @@
         }
 
-        public void setAnchorLeft(Float anchor) {
-                this._anchorLeft = anchor;
-                this._anchorRight = null;
+        public void setAnchorLeft(Integer anchor)
+        {
+                this._anchoring.setLeftAnchor(anchor);
                 if (anchor != null) {
                         anchorConstraints();
@@ -2873 +3090 @@
         }
 
-        public void setAnchorRight(Float anchor) {
-                this._anchorRight = anchor;
-                this._anchorLeft = null;
+        public void setAnchorRight(Integer anchor)
+        {
+                this._anchoring.setRightAnchor(anchor);
                 if (anchor != null) {
                         anchorConstraints();
-                        setX(FrameGraphics.getMaxFrameSize().width - anchor
-                                        - getBoundsWidth());
-                }
-        }
-
-        public void setAnchorTop(Float anchor) {
-                this._anchorTop = anchor;
-                this._anchorBottom = null;
+                        setX(DisplayController.getFramePaintArea().getMaxX() - anchor - getBoundsWidth());
+                }
+        }
+
+        public void setAnchorTop(Integer anchor)
+        {
+                this._anchoring.setTopAnchor(anchor);
                 if (anchor != null) {
                         anchorConstraints();
@@ -2893 +3109 @@
 
 
-        public void setAnchorBottom(Float anchor) {
-                this._anchorBottom = anchor;
-                this._anchorTop = null;
+        public void setAnchorBottom(Integer anchor)
+        {
+                this._anchoring.setBottomAnchor(anchor);
                 if (anchor != null) {
                         anchorConstraints();
-                        setY(FrameGraphics.getMaxFrameSize().height - anchor);
-                }
-        }
-
-
-        public boolean isAnchored() {
-            return ((_anchorLeft != null) || (_anchorRight != null) 
-                    || (_anchorTop != null) || (_anchorBottom != null));
+                        setY(DisplayController.getFramePaintArea().getMaxY() - anchor);
+                }
+        }
+
+        public boolean isAnchored()
+        {
+            return _anchoring.isAnchored();
         }
 
         public boolean isAnchoredX() {
-            return ((_anchorLeft != null) || (_anchorRight != null));
+            return _anchoring.isXAnchored();
         }
 
         public boolean isAnchoredY() {
-            return ((_anchorTop != null) || (_anchorBottom != null));
-        }
-
-        public Float getAnchorLeft() {
-                return _anchorLeft;
-        }
-
-        public Float getAnchorRight() {
-                return _anchorRight;
-        }
-
-        public Float getAnchorTop() {
-                return _anchorTop;
-        }
-
-        public Float getAnchorBottom() {
-                return _anchorBottom;
+            return _anchoring.isYAnchored();
+        }
+
+        public Integer getAnchorLeft() {
+                return _anchoring.getLeftAnchor();
+        }
+
+        public Integer getAnchorRight() {
+                return _anchoring.getRightAnchor();
+        }
+
+        public Integer getAnchorTop() {
+                return _anchoring.getTopAnchor();
+        }
+
+        public Integer getAnchorBottom() {
+                return _anchoring.getBottomAnchor();
         }
 
@@ -3024 +3239 @@
                 // Invalidate them again!!
                 for (Item i : this.getAllConnected()) {
-                        i.updatePolygon();
+                        i.invalidateBounds();
                         i.invalidateAll();
                 }
         }
 
-        
         protected void anchorConnected(AnchorEdgeType anchorEdgeType, Float delta) {
                 
@@ -3087 +3301 @@
                 // Invalidate them again!!
                 for (Item i : this.getAllConnected()) {
-                        i.updatePolygon();
+                        i.invalidateBounds();
                         i.invalidateAll();
                 }
@@ -3123 +3337 @@
                 // DONT PUT SIZE IN HERE CAUSE IT STUFFS UP CIRCLES
 
-                updatePolygon();
+                invalidateBounds();
         }
 
@@ -3168 +3382 @@
                 return _autoStamp != null && _autoStamp >= 0.0;
         }
-
-        public void setDotType(DotType type) {
-                invalidateAll();
-                _type = type;
-                invalidateAll();
-        }
-
-        public DotType getDotType() {
-                return _type;
-        }
-
-        public void setFilled(boolean filled) {
-                invalidateAll();
-                _filled = filled;
-                invalidateAll();
-        }
-
-        public boolean getFilled() {
-                return _filled;
-        }
-                
-        private Item _magnetizedItemLeft = null;
-        private Item _magnetizedItemRight = null;
-        private Item _magnetizedItemTop = null;
-        private Item _magnetizedItemBottom = null;
         
         public int getMagnetizedItemLeft() {
@@ -3245 +3434 @@
                 setMagnetizedItemBottom(this.getParent().getItemWithID(id));
         }
+
+        /**
+         * 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.getItems());
+                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.getItems());
+                return dot;
+        }
 }