Changeset 1101

Timestamp:

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

Author:

davidb

Message:

Merging of Bryce's change in getPixelBoundsUnion() with Corey's logic/graphics separation

File:

• trunk/src/org/expeditee/items/Text.java (modified) (103 diffs)

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

@@ -19 +19 @@
 package org.expeditee.items;
 
-import java.awt.BasicStroke;
-import java.awt.Color;
-import java.awt.Dimension;
-import java.awt.Font;
-import java.awt.GradientPaint;
-import java.awt.Graphics2D;
-import java.awt.GraphicsEnvironment;
-import java.awt.Point;
-import java.awt.Polygon;
-import java.awt.Rectangle;
-import java.awt.Shape;
-import java.awt.Stroke;
-import java.awt.event.KeyEvent;
-import java.awt.event.MouseEvent;
-import java.awt.font.FontRenderContext;
-import java.awt.font.LineBreakMeasurer;
-import java.awt.font.TextAttribute;
-import java.awt.font.TextHitInfo;
-import java.awt.font.TextLayout;
-import java.awt.geom.AffineTransform;
-import java.awt.geom.Point2D;
-import java.awt.geom.Rectangle2D;
 import java.io.File;
 
-import java.text.AttributedString;
 import java.util.ArrayList;
 import java.util.Collection;
@@ -52 +29 @@
 import java.util.StringTokenizer;
 
+import org.expeditee.core.Colour;
+import org.expeditee.core.Dimension;
+import org.expeditee.core.Fill;
+import org.expeditee.core.Font;
+import org.expeditee.core.GradientFill;
+import org.expeditee.core.Point;
+import org.expeditee.core.Range;
+import org.expeditee.core.Stroke;
+import org.expeditee.core.TextHitInfo;
+import org.expeditee.core.TextLayout;
+import org.expeditee.core.bounds.AxisAlignedBoxBounds;
+import org.expeditee.core.bounds.CombinationBoxBounds;
+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;
+import org.expeditee.gui.MessageBay;
 import org.expeditee.items.MagneticConstraint.MagneticConstraints;
 import org.expeditee.math.ExpediteeJEP;
 import org.expeditee.settings.experimental.ExperimentalFeatures;
+import org.expeditee.stats.Formatter;
 import org.nfunk.jep.Node;
 
@@ -75 +67 @@
 public class Text extends Item {
         private static final int ADJUST_WIDTH_THRESHOLD = 200;
+        
+        public static final char DELETE_CHARACTER = 0x7F;
+        
+        public static final char BACKSPACE_CHARACTER = '\b';
+        
+        public static final char TAB_CHARACTER = '\t';
+        
+        public static final char ESC_CHARACTER = 0x1B;
 
         public static String LINE_SEPARATOR = System.getProperty("line.separator");
@@ -97 +97 @@
         public static final String FRAME_NAME_SEPARATOR = " on frame ";
 
-        /**
-         * The default font used to display text items if no font is specified.
-         */
+        /** The default font used to display text items if no font is specified. */
         public static final String DEFAULT_FONT = "Serif-Plain-18";
 
-        public static final Color DEFAULT_COLOR = Color.BLACK;
+        public static final Colour DEFAULT_COLOR = Colour.BLACK;
 
         public static final int MINIMUM_RANGED_CHARS = 2;
@@ -128 +126 @@
         public static final int PAGE_UP = 8;
 
-        /*
+        /**
          * Set the width to be IMPLICIT, but as wide as possible, a negative width value
          * is one that is implicitly set by the system... a positive value is one
          * explicitly set by the user.
          */
-        private Integer _maxWidth = Integer.MIN_VALUE + 1;
+        /**
+         * The maximum allowable width of the Text item. Actual width may be less than this
+         * value, subject to text wrapping. Negative values indicate the width was implicitly
+         * set by the system, positive values indicate explicit setting by the user. Initially
+         * set to be as wide as possible.
+         */
+        private Integer _maxWidth = -Integer.MAX_VALUE;
 
         private Justification _justification = Justification.left;
@@ -150 +154 @@
         private int _selectionEnd = -1;
 
+        /** Keeps track of the last Text item selected. */
+        private static Text _lastSelected = null;
+        
+        // Range selection colours
+        /** Colour of selected range when for selecting text. */
+        public static final Colour RANGE_SELECT_COLOUR = Colour.FromRGB255(255, 160, 160);
+        /** Colour of selected range when for cutting text. */
+        public static final Colour RANGE_CUT_COLOUR = Colour.FromRGB255(160, 255, 160);
+        /** Colour of selected range when for copying text. */
+        public static final Colour RANGE_COPY_COLOUR = Colour.FromRGB255(160, 160, 255);
+        /** Colour of selected range when for deleting text. */
+        public static final Colour RANGE_DELETE_COLOUR = Colour.FromRGB255(235, 235, 140);
+        
+        /** The colour to draw range selections in. */
+        private Colour _selectionColour = RANGE_SELECT_COLOUR;
+                
         // whether autowrap is on/off for this item
         protected boolean _autoWrap = false;
@@ -158 +178 @@
         private List<TextLayout> _textLayouts = new LinkedList<TextLayout>();
 
-        private List<Integer> _lineOffsets = new LinkedList<Integer>();
-
-        private FontRenderContext frc = null;
-        private LineBreakMeasurer _lineBreaker = null;
-
         // The font to display this text in
         private Font _font;
 
-        protected static void InitFontFamily(GraphicsEnvironment ge, File fontFamilyDir) {
+        protected static void InitFontFamily(File fontFamilyDir)
+        {
                 File[] fontFiles = fontFamilyDir.listFiles();
 
@@ -183 +199 @@
 
                                 try {
-                                        Font font = Font.createFont(Font.TRUETYPE_FONT, fontFile);
-
-                                        boolean registered_status_ok = ge.registerFont(font);
-
-                                        if (registered_status_ok) {
-
-                                                String font_family = font.getFamily();
-                                                if (!FONT_WHEEL_ADDITIONAL_LOOKUP.containsKey(font_family)) {
+                                        Font font = EcosystemManager.getFontManager().registerFontFile(fontFile);
+
+                                        if (font != null) {
+                                            
+                                            String font_family = font.getFamilyName();
+                                            if (!FONT_WHEEL_ADDITIONAL_LOOKUP.containsKey(font_family)) {
 
                                                         if (FONT_WHEEL_ADDITIONAL_LOOKUP.size() > 0) {
                                                                 System.out.print(", ");
                                                         }
-                                                        System.out.print("'" + font.getFamily() + "'");
+                                                        System.out.print("'" + font_family + "'");
 
                                                         FONT_WHEEL_ADDITIONAL_LOOKUP.put(font_family, font);
 
+                                                        /*
                                                         int cdut = font.canDisplayUpTo("09AZaz");
                                                         if (cdut >= 0) {
@@ -205 +220 @@
                                                                 System.out.println(" [Non-ASCII font]");
                                                         }
+                                                        */
                                                         System.out.flush();
                                                 }
 
+                                                System.out.print("'" + font_family + "'");
                                         } else {
                                                 System.err.println("Error: Failed to add custom True-Type Font file: " + fontFile);
@@ -221 +238 @@
         public static void InitFonts() {
 
-                GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
-
-                if (ge != null) {
-
-                        File fontDirectory = new File(FrameIO.FONT_PATH);
-                        if (fontDirectory != null) {
-                                File[] fontFamilyDirs = fontDirectory.listFiles();
-                                if (fontFamilyDirs != null) {
-
-                                        if (fontFamilyDirs.length > 0) {
-                                                System.out.println("Loading custom fonts:");
+                File fontDirectory = new File(FrameIO.FONT_PATH);
+                if (fontDirectory != null) {
+                        File[] fontFamilyDirs = fontDirectory.listFiles();
+                        if (fontFamilyDirs != null) {
+
+                                if (fontFamilyDirs.length > 0) {
+                                        System.out.println("Loading custom fonts:");
+                                }
+
+                                for (File fontFamilyDir : fontFamilyDirs) {
+                                        if (fontFamilyDir.isDirectory()) {
+                                                InitFontFamily(fontFamilyDir);
                                         }
-
-                                        boolean first_item = true;
-                                        for (File fontFamilyDir : fontFamilyDirs) {
-                                                if (fontFamilyDir.isDirectory()) {
-                                                        InitFontFamily(ge, fontFamilyDir);
-                                                }
-                                        }
-                                        System.out.println();
                                 }
-                        }
-                } else {
-                        System.err.println("No graphics environment detected.  Skipping the loading of the custom fonts");
+                                System.out.println();     
+                        }
                 }
         }
@@ -359 +368 @@
         }
 
-        public Text(int i, String string, Color foreground, Color background) {
+        public Text(int i, String string, Colour foreground, Colour background) {
                 this(i, string);
                 this.setColor(foreground);
@@ -366 +375 @@
 
         /**
+<<<<<<< .mine
+         * Sets the maximum width of this Text item when justification is used.
+         * passing in 0 or -1 means there is no maximum width
+||||||| .r1094
+         * Sets the maximum width of this Text item when justifcation is used.
+         * passing in 0 or -1 means there is no maximum width
+=======
          * Sets the maximum width of this Text item when justifcation is used. passing
          * in 0 or -1 means there is no maximum width
+>>>>>>> .r1100
          * 
          * @param width
@@ -379 +396 @@
                 if (width == null) {
                         setJustification(Justification.left);
-                        setRightMargin(FrameGraphics.getMaxFrameSize().width, false);
+                        setRightMargin(DisplayController.getFramePaintArea().getWidth(), false);
                         return;
                 }
@@ -389 +406 @@
 
         /**
+<<<<<<< .mine
+         * Returns the maximum width of this Text item when justification is used. If
+         * the width is negative, it means no explicit width has been set
+||||||| .r1094
+         * Returns the maximum width of this Text item when justifcation is used. If
+         * the width is negative, it means no explicit width has been set
+=======
          * Returns the maximum width of this Text item when justifcation is used. If the
          * width is negative, it means no explicit width has been set
+>>>>>>> .r1100
          * 
          * @return The maximum width of this Text item when justification is used
          */
         @Override
-        public Integer getWidth() {
-                if (_maxWidth == null || _maxWidth <= 0)
-                        return null;
+        public Integer getWidth()
+        {
+                if (_maxWidth == null || _maxWidth <= 0) return null;
+                
                 return _maxWidth;
         }
@@ -410 +436 @@
 
         @Override
-        public Color getHighlightColor() {
-                if (_highlightColor.equals(getPaintBackgroundColor()))
+        public Colour getHighlightColor() {
+                if (_highlightColour.equals(getPaintBackgroundColor()))
                         return ALTERNATE_HIGHLIGHT;
-                return _highlightColor;
+                return _highlightColour;
         }
 
@@ -441 +467 @@
          * justification.
          * 
+         * TODO: Why return null when justification is set to left? cts16
+         * 
          * @return The justification of this Text item
          */
-        public Justification getJustification() {
-                if (_justification == null || _justification.equals(Justification.left))
-                        return null;
+        public Justification getJustification()
+        {
+                if (_justification == null || _justification.equals(Justification.left)) return null;
+                
                 return _justification;
         }
 
+        /**
+         * Gets the distance from the left of the bounding box that the given layout
+         * should be shifted to justify it.
+         * 
+         * @param layout
+         *              The line of text to calculate the justification offset for.
+         * 
+         * @return
+         *              The distance to shift the line of text by.
+         */
         private int getJustOffset(TextLayout layout) {
                 if (getJustification() == Justification.center)
@@ -519 +558 @@
          *            The String to insert.
          */
-        public void prependText(String text) {
-
+        public void prependText(String text)
+        {
+                invalidateAll();
                 _text.insert(0, text);
                 rebuild(false);
+                invalidateAll();
         }
 
@@ -534 +575 @@
         public void removeText(String text) {
                 if (_text.length() > 0 && _text.indexOf(text) == 0) {
-                        // Need the invalidate all for dateStamp toggling
                         invalidateAll();
                         _text.delete(0, text.length());
+                        invalidateAll();
                 }
 
@@ -544 +585 @@
                 int length = _text.length();
                 if (length > 0) {
-                        // invalidateAll();
                         int pos = _text.indexOf(textToRemove);
                         int textToRemoveLength = textToRemove.length();
                         if (pos + textToRemoveLength == length) {
+                                // Need the invalidate all for dateStamp toggling
+                                invalidateAll();
                                 _text.delete(pos, length);
+                                invalidateAll();
                         }
                 }
@@ -561 +604 @@
          */
         public void appendText(String text) {
+                invalidateAll();
                 _text.append(text);
                 rebuild(false);
+                invalidateAll();
         }
 
@@ -614 +659 @@
          *            The Y position to insert the Strings at.
          */
-        public Point2D.Float insertChar(char ch, float mouseX, float mouseY) {
+        public Point insertChar(char ch, float mouseX, float mouseY) {
                 if (ch != '\t') /* && ch != '\n' */
                         return insertText("" + ch, mouseX, mouseY);
@@ -641 +686 @@
         }
 
-        public Point2D.Float getLineEndPosition(float mouseY) {
+        public Point getLineEndPosition(float mouseY) {
                 return getEdgePosition(getLinePosition(mouseY), false);
         }
 
-        public Point2D.Float getLineStartPosition(float mouseY) {
+        public Point getLineStartPosition(float mouseY) {
                 return getEdgePosition(getLinePosition(mouseY), true);
         }
 
-        public Point2D.Float getParagraphEndPosition() {
+        public Point getParagraphEndPosition() {
                 return getEdgePosition(_textLayouts.size() - 1, false);
         }
 
-        public Point2D.Float getParagraphStartPosition() {
+        public Point getParagraphStartPosition() {
                 return getEdgePosition(0, true);
         }
 
-        private Point2D.Float getEdgePosition(int line, boolean start) {
+        private Point getEdgePosition(int line, boolean start) {
                 // if there is no text yet, or the line is invalid
                 if (_text == null || _text.length() == 0 || line < 0 || line > _textLayouts.size() - 1)
-                        return new Point2D.Float(getX(), getY());
+                        return new Point(getX(), getY());
 
                 TextLayout last = _textLayouts.get(line);
@@ -674 +719 @@
 
                 float x = getX() + caret[0] + getJustOffset(last);
-                x = Math.min(x, (getX() - Item.MARGIN_RIGHT - (2 * getGravity()) + getBoundsWidth()));
-                return new Point2D.Float(x, getY() + y + caret[1]);
-        }
-
+
+                x = Math.min(
+                                                x,
+                                                (getX() - Item.MARGIN_RIGHT - (2 * getGravity()) + getBoundsWidth())
+                );
+                return new Point((int) x, (int) (getY() + y + caret[1]));
+        }
+
+        public void setSelectionStart(Point p)
+        {
+                setSelectionStart(p.x, p.y);
+        }
+        
         public void setSelectionStart(float mouseX, float mouseY) {
                 // determine what line is being pointed to
@@ -684 +738 @@
                 // get the character being pointed to
                 TextHitInfo hit = getCharPosition(line, mouseX);
-                _selectionStart = hit.getInsertionIndex() + _lineOffsets.get(line);
-                invalidateAll();
+                _selectionStart = hit.getInsertionIndex() + _textLayouts.get(line).getStartCharIndex();
+                
+                // Clear the last selected
+                updateLastSelected();
+                
+                invalidateAll();
+        }
+
+        public void setSelectionEnd(Point p)
+        {
+                setSelectionEnd(p.x, p.y);
         }
 
@@ -694 +757 @@
                 // get the character being pointed to
                 TextHitInfo hit = getCharPosition(line, mouseX);
-                _selectionEnd = hit.getInsertionIndex() + _lineOffsets.get(line);
+                _selectionEnd = hit.getInsertionIndex() + _textLayouts.get(line).getStartCharIndex();
+                
+                // Clear the last selected
+                updateLastSelected();
+                
                 invalidateAll();
         }
@@ -707 +774 @@
                 _selectionEnd = -1;
                 invalidateAll();
+        }
+        
+        /** Makes sure only one text has a selection at a time. */
+        public void updateLastSelected()
+        {
+                if (_lastSelected != this) {
+                        if (_lastSelected != null) _lastSelected.clearSelection();
+                        _lastSelected = this;
+                }
         }
 
@@ -784 +860 @@
          * @return The new location that the mouse cursor should be moved to
          */
-        public Point2D.Float insertText(String text, float mouseX, float mouseY) {
-                final Point2D.Float newPos = insertText(text, mouseX, mouseY, -1);
+        public Point insertText(String text, float mouseX, float mouseY)
+        {
+                final Point newPos = insertText(text, mouseX, mouseY, -1);
                 return newPos;
         }
 
-        public Point2D.Float insertText(String text, float mouseX, float mouseY, int insertPos) {
+        public Point insertText(String text, float mouseX, float mouseY, int insertPos)
+        {
                 TextHitInfo hit;
                 TextLayout current = null;
-                int line;
+                int lineIndex;
 
                 invalidateAll();
@@ -798 +876 @@
                 // check for empty string
                 if (text == null || text.length() == 0)
-                        return new Point2D.Float(mouseX, mouseY);
+                        return new Point((int) mouseX, (int) mouseY);
 
                 // if there is no text yet
@@ -808 +886 @@
                         current = _textLayouts.get(0);
                         hit = current.getNextRightHit(0);
-                        line = 0;
+                        lineIndex = 0;
 
                         // otherwise, we are inserting text
@@ -814 +892 @@
                         clearCache();
                         // determine what line is being pointed to
-                        line = getLinePosition(mouseY);
+                        lineIndex = getLinePosition(mouseY);
 
                         // get the character being pointed to
-                        hit = getCharPosition(line, mouseX);
-
-                        int pos = hit.getInsertionIndex() + _lineOffsets.get(line);
-
-                        if (line > 0 && hit.getInsertionIndex() == 0) {
+                        hit = getCharPosition(lineIndex, mouseX);
+
+                        int insertionIndex = hit.getInsertionIndex() + _textLayouts.get(lineIndex).getStartCharIndex();
+
+                        if (lineIndex > 0 && hit.getInsertionIndex() == 0) {
                                 // Only move forward a char if the line begins with a hard line
                                 // break... not a soft line break
-                                if (_text.charAt(pos) == '\n') {
-                                        pos++;
+                                if (_text.charAt(insertionIndex) == '\n') {
+                                        insertionIndex++;
                                 }
                         }
 
                         if (insertPos < 0)
-                                insertPos = pos;
+                                insertPos = insertionIndex;
 
                         // if this is a backspace key
-                        if (text.charAt(0) == KeyEvent.VK_BACK_SPACE) {
+                        if (text.charAt(0) == '\b') {
                                 if (hasSelection()) {
-                                        pos = deleteSelection(pos);
+                                        insertionIndex = deleteSelection(insertionIndex);
                                 } else if (insertPos > 0) {
                                         deleteChar(insertPos - 1);
-                                        if (pos > 0)
-                                                pos--;
+                                        if (insertionIndex > 0)
+                                                insertionIndex--;
                                 }
-                                // if this is a delete key
-                        } else if (text.charAt(0) == KeyEvent.VK_DELETE) {
+                        // if this is a delete key
+                        } else if (text.charAt(0) == (char) 0x7F) {
                                 if (hasSelection()) {
-                                        pos = deleteSelection(pos);
+                                        insertionIndex = deleteSelection(insertionIndex);
                                 } else if (insertPos < _text.length()) {
                                         deleteChar(insertPos);
                                 }
-                                // this is a tab
-                        } else if (text.charAt(0) == KeyEvent.VK_TAB) {
+                        // this is a tab
+                        } else if (text.charAt(0) == '\t') {
                                 // Text length greater than 1 signals a backwards tab
                                 if (text.length() > 1) {
@@ -867 +945 @@
                                                 if (_text.length() > 0 && Character.isSpaceChar(_text.charAt(0))) {
                                                         deleteChar(0);
-                                                        pos--;
+                                                        insertionIndex--;
                                                 } else
                                                         break;
                                         }
-                                        _lineBreaker = null;
                                 } else {
                                         // / Find the first non space char to see if its a bullet
@@ -887 +964 @@
                                         // Insert the spacing at the start
                                         insertString(TAB_STRING, 0);
-                                        pos += TAB_STRING.length();
+                                        insertionIndex += TAB_STRING.length();
                                 }
-                                // this is a normal insert
+                        // this is a normal insert
                         } else {
                                 insertString(text, insertPos);
-                                pos += text.length();
+                                insertionIndex += text.length();
                         }
 
                         if (_text.length() == 0) {
                                 rebuild(false);
-                                return new Point2D.Float(this._x, this._y);
-                        }
-
-                        int newLine = line;
+                                return new Point((int) this._x, (int) this._y);
+                        }
+
+                        int newLine = lineIndex;
 
                         // if a rebuild is required
@@ -906 +983 @@
 
                         // determine the new position the cursor should have
-                        for (int i = 1; i < _lineOffsets.size(); i++) {
-                                if (_lineOffsets.get(i) >= pos) {
-                                        newLine = i - 1;
+                        for (int i = 0; i < _textLayouts.size(); i++) {
+                                if (_textLayouts.get(i).getEndCharIndex() + 1 >= insertionIndex) {
+                                        newLine = i;
                                         break;
                                 }
@@ -914 +991 @@
 
                         current = _textLayouts.get(newLine);
-                        pos -= _lineOffsets.get(newLine);
-
-                        if (newLine == line) {
-                                if (pos > 0)
-                                        hit = current.getNextRightHit(pos - 1);
+                        insertionIndex -= current.getStartCharIndex();
+
+                        if (newLine == lineIndex) {
+                                if (insertionIndex > 0)
+                                        hit = current.getNextRightHit(insertionIndex - 1);
                                 else
                                         hit = current.getNextLeftHit(1);
-                        } else if (newLine < line) {
-                                hit = current.getNextRightHit(pos - 1);
+                        } else if (newLine < lineIndex) {
+                                hit = current.getNextRightHit(insertionIndex - 1);
                         } else {
-                                hit = current.getNextRightHit(pos - 1);
-                        }
-
-                        line = newLine;
+                                hit = current.getNextRightHit(insertionIndex - 1);
+                        }
+
+                        lineIndex = newLine;
                 }
 
                 // move the cursor to the new location
                 float[] caret = current.getCaretInfo(hit);
-                float y = getLineDrop(current) * line;
+                float y = getLineDrop(current) * lineIndex;
 
                 float x = getX() + caret[0] + getJustOffset(current);
-                x = Math.min(x, (getX() - Item.MARGIN_RIGHT - (2 * getGravity()) + getBoundsWidth()));
-
-                invalidateAll();
-
-                return new Point2D.Float(Math.round(x), Math.round(getY() + y + caret[1]));
+                x = Math.min(
+                                                x,
+                                                (getX() - Item.MARGIN_RIGHT - (2 * getGravity()) + getBoundsWidth())
+                );
+
+                invalidateAll();
+
+                return new Point(Math.round(x), Math.round(getY() + y + caret[1]));
         }
 
@@ -963 +1043 @@
         }
 
-        public Point2D.Float moveCursor(int direction, float mouseX, float mouseY, boolean setSelection,
-                        boolean wholeWord) {
+        public Point moveCursor(int direction, float mouseX, float mouseY, boolean setSelection, boolean wholeWord)
+        {
                 if (setSelection) {
                         if (!hasSelection()) {
@@ -973 +1053 @@
                 }
 
-                Point2D.Float resultPos = null;
+                Point resultPos = null;
 
                 // check for home or end keys
@@ -996 +1076 @@
                         // if there is no text yet
                         if (_text == null || _text.length() == 0) {
-                                return new Point2D.Float(mouseX, mouseY);
+                                return new Point((int) mouseX, (int) mouseY);
                                 // otherwise, move the cursor
                         } else {
@@ -1024 +1104 @@
                                                         // Keep going if the char to the left is a
                                                         // letterOrDigit
-                                                        prevChar = _text.charAt(hit.getInsertionIndex() - 1 + _lineOffsets.get(line));
+                                                        prevChar = _text.charAt(hit.getInsertionIndex() - 1 + _textLayouts.get(line).getStartCharIndex());
                                                 } while (wholeWord && Character.isLetterOrDigit(prevChar));
-                                                // TODO Go to the start of the word instead of before
-                                                // the word
-                                                char nextChar = _text.charAt(hit.getInsertionIndex() + _lineOffsets.get(line));
-                                                /*
-                                                 * This takes care of hard line break in
-                                                 */
+                                                
+                                                // TODO Go to the start of the word instead of before the word
+                                                char nextChar = _text.charAt(hit.getInsertionIndex() + _textLayouts.get(line).getStartCharIndex());
+                                                
+                                                // This takes care of hard line break in
                                                 if (line > 0 && nextChar == '\n') {
                                                         line--;
-                                                        hit = _textLayouts.get(line)
-                                                                        .getNextRightHit(_textLayouts.get(line).getCharacterCount() - 1);
+                                                        hit = _textLayouts.get(line).getNextRightHit(_textLayouts.get(line).getCharacterCount() - 1);
                                                 }
-                                                // This takes care of soft line breaks.
+                                                
+                                        // This takes care of soft line breaks.
                                         } else if (line > 0) {
                                                 line--;
                                                 hit = _textLayouts.get(line).getNextRightHit(_textLayouts.get(line).getCharacterCount() - 1);
-                                                /*
-                                                 * Skip the spaces at the end of a line with soft linebreak
-                                                 */
-                                                while (hit.getCharIndex() > 0
-                                                                && _text.charAt(_lineOffsets.get(line) + hit.getCharIndex() - 1) == ' ') {
+                                                
+                                                // Skip the spaces at the end of a line with soft linebreak
+                                                while (hit.getCharIndex() > 0 && _text.charAt(_textLayouts.get(line).getStartCharIndex() + hit.getCharIndex() - 1) == ' ') {
                                                         hit = _textLayouts.get(line).getNextLeftHit(hit);
                                                 }
@@ -1053 +1130 @@
                                                 hit = _textLayouts.get(line).getNextRightHit(hit);
                                                 // Skip whole word if needs be
-                                                while (wholeWord && hit.getCharIndex() > 0
-                                                                && hit.getCharIndex() < _textLayouts.get(line).getCharacterCount() && Character
-                                                                                .isLetterOrDigit(_text.charAt(_lineOffsets.get(line) + hit.getCharIndex() - 1)))
+                                                while (wholeWord
+                                                                && hit.getCharIndex() > 0
+                                                                && hit.getCharIndex() < _textLayouts.get(line).getCharacterCount()
+                                                                && Character.isLetterOrDigit(_text.charAt(_textLayouts.get(line).getStartCharIndex() + hit.getCharIndex() - 1)))
+                                                {
                                                         hit = _textLayouts.get(line).getNextRightHit(hit);
+                                                }
                                         } else if (line < _textLayouts.size() - 1) {
                                                 line++;
@@ -1069 +1149 @@
                         float y = getLineDrop(current) * line;
 
-                        resultPos = new Point2D.Float(getX() + caret[0] + getJustOffset(current), getY() + y + caret[1]);
+                        resultPos = new Point((int) (getX() + caret[0] + getJustOffset(current)), (int) (getY() + y + caret[1]));
+
                         break;
                 }
-                if (setSelection)
-                        setSelectionEnd(resultPos.x, resultPos.y);
+                
+                if (setSelection) setSelectionEnd(resultPos.x, resultPos.y);
+                
                 return resultPos;
         }
@@ -1098 +1180 @@
         }
 
+        /**
+         * Gets the index into the <code>_textLayout</code> list which corresponds to the line
+         * covered by the given <code>mouseY</code> position.
+         * 
+         * @param mouseY
+         *              The y-coordinate to test for line coverage.
+         * 
+         * @return
+         *              The line which occupies the given y-coordinate, or the last line if none do.
+         */
         public int getLinePosition(float mouseY) {
                 mouseY += getOffset().y;
@@ -1105 +1197 @@
                 for (TextLayout text : _textLayouts) {
                         // calculate X to ensure it is in the shape
-                        Rectangle2D bounds = text.getLogicalHighlightShape(0, text.getCharacterCount()).getBounds2D();
-
-                        if (bounds.getWidth() < 1)
-                                bounds.setRect(bounds.getMinX(), bounds.getMinY(), 10, bounds.getHeight());
-
-                        double x = bounds.getCenterX();
-
-                        if (bounds.contains(x, mouseY - getY() - (y - getY())))
+                        AxisAlignedBoxBounds bounds = text.getLogicalHighlightShape(0, text.getCharacterCount());
+
+                        if (bounds.getWidth() < 1) bounds.getSize().width = 10;
+
+                        double x = bounds.getCentreX();
+
+                        if (bounds.contains((int) x, (int) (mouseY - y)))
                                 return _textLayouts.indexOf(text);
 
                         // check if the cursor is between lines
-                        if (mouseY - getY() - (y - getY()) < bounds.getMinY())
+                        if (mouseY - y < bounds.getMinY())
                                 return Math.max(0, _textLayouts.indexOf(text) - 1);
 
@@ -1131 +1222 @@
          *            The Font to display the Text of this Item in.
          */
-        public void setFont(Font font) {
+        public void setFont(Font font)
+        {
                 invalidateAll();
                 // all decoding occurs in the Utils class
@@ -1142 +1234 @@
 
         /**
-         * Returns the Font that this Text is currently using when painting to the
-         * screen
-         * 
-         * @return The Font used to display this Text on the screen.
+         * Gets the font of this text item.
+         * 
+         * @return The Font assigned to this text item, or null if none is assigned.
          */
         public Font getFont() {
@@ -1151 +1242 @@
         }
 
-        public Font getPaintFont() {
-                if (getFont() == null)
-                        return Font.decode(DEFAULT_FONT);
+        /**
+         * Gets the font that should be used to paint this text item during drawing.
+         * 
+         * @return The font to paint the text item with.
+         */
+        public Font getPaintFont()
+        {
+                if (getFont() == null) return EcosystemManager.getFontManager().getDefaultFont();
 
                 return getFont();
@@ -1159 +1255 @@
 
         public String getFamily() {
-                return getPaintFont().getFamily();
-        }
-
-        public void setFamily(String newFamily) {
-                String toDecode = newFamily + "-" + getFontStyle() + "-" + Math.round(getSize());
-                setFont(Font.decode(toDecode));
+                return getPaintFont().getFamilyName();
+        }
+
+        public void setFamily(String newFamily)
+        {
+                setFont(new Font(newFamily, getFontStyle(), Math.round(getSize())));
 
                 setLetterSpacing(this._letter_spacing);
         }
 
-        public String getFontStyle() {
+        public Font.Style getFontStyle() {
                 Font f = getPaintFont();
-                String s = "";
-
-                if (f.isPlain())
-                        s += "Plain";
-
-                if (f.isBold())
-                        s += "Bold";
-
-                if (f.isItalic())
-                        s += "Italic";
-
-                return s;
+                return f.getStyle();
         }
 
@@ -1215 +1300 @@
                 invalidateAll();
                 Font currentFont = getPaintFont();
-                if (currentFont.isPlain())
-                        setFont(currentFont.deriveFont(Font.BOLD));
-                else if (currentFont.isBold() && currentFont.isItalic())
-                        setFont(currentFont.deriveFont(Font.PLAIN));
-                else if (currentFont.isBold())
-                        setFont(currentFont.deriveFont(Font.ITALIC));
-                else
-                        setFont(currentFont.deriveFont(Font.ITALIC + Font.BOLD));
+                Font.Style currentStyle = currentFont.getStyle();
+                Font.Style newStyle = Font.Style.PLAIN;
+                switch (currentStyle) {
+                        case PLAIN:
+                                newStyle = Font.Style.BOLD;
+                                break;
+                        case BOLD:
+                                newStyle = Font.Style.ITALIC;
+                                break;
+                        case ITALIC:
+                                newStyle = Font.Style.BOLD_ITALIC;
+                                break;
+                        default:
+                                newStyle = Font.Style.PLAIN;
+                                break;
+                }
+                setFont(new Font(currentFont.getFamilyName(), newStyle, currentFont.getSize()));
                 rebuild(true);
                 invalidateAll();
@@ -1230 +1324 @@
                 invalidateAll();
                 Font currentFont = getPaintFont();
-                int newStyle = currentFont.getStyle();
-                if (currentFont.isBold()) {
-                        newStyle -= Font.BOLD;
-                } else {
-                        newStyle += Font.BOLD;
-                }
-                setFont(currentFont.deriveFont(newStyle));
+                currentFont.toggleBold();
+                setFont(currentFont);
                 rebuild(true);
                 invalidateAll();
@@ -1244 +1333 @@
                 invalidateAll();
                 Font currentFont = getPaintFont();
-                int newStyle = currentFont.getStyle();
-                if (currentFont.isItalic()) {
-                        newStyle -= Font.ITALIC;
-                } else {
-                        newStyle += Font.ITALIC;
-                }
-                setFont(currentFont.deriveFont(newStyle));
+                currentFont.toggleItalic();
+                setFont(currentFont);
                 rebuild(true);
                 invalidateAll();
         }
 
-        public void setFontStyle(String newFace) {
+        public void setFontStyle(String newFace)
+        {
+                Font currentFont = getPaintFont();
                 if (newFace == null || newFace.trim().length() == 0) {
-                        setFont(getPaintFont().deriveFont(Font.PLAIN));
+                        currentFont.setStyle(Font.Style.PLAIN);
+                        setFont(currentFont);
                         return;
                 }
@@ -1264 +1351 @@
 
                 if (newFace.equals("plain") || newFace.equals("p")) {
-                        setFont(getPaintFont().deriveFont(Font.PLAIN));
+                        currentFont.setStyle(Font.Style.PLAIN);
                 } else if (newFace.equals("bold") || newFace.equals("b")) {
-                        setFont(getPaintFont().deriveFont(Font.BOLD));
+                        currentFont.setStyle(Font.Style.BOLD);
                 } else if (newFace.equals("italic") || newFace.equals("i")) {
-                        setFont(getPaintFont().deriveFont(Font.ITALIC));
-                } else if (newFace.equals("bolditalic") || newFace.equals("italicbold") || newFace.equals("bi")
-                                || newFace.equals("ib")) {
-                        setFont(getPaintFont().deriveFont(Font.BOLD + Font.ITALIC));
-                }
+                        currentFont.setStyle(Font.Style.ITALIC);
+                } else if (newFace.equals("bolditalic") || newFace.equals("italicbold") || newFace.equals("bi") || newFace.equals("ib")) {
+                        currentFont.setStyle(Font.Style.BOLD_ITALIC);
+                }
+                
+                setFont(currentFont);
 
         }
@@ -1289 +1377 @@
 
                         // Rebuilding prevents errors when displaying frame bitmaps
-                        if (_lineOffsets.size() == 0) {
+                        if (_textLayouts.size() == 0) {
                                 rebuild(false);
                         }
 
-                        int last = 0;
-                        for (int offset : _lineOffsets) {
-                                if (offset != last) {
-                                        list.add(_text.substring(last, offset).replaceAll("\n", ""));
-                                }
-                                last = offset;
+                        for (TextLayout layout : _textLayouts) {
+                                String text = layout.getLine().replaceAll("\n", "");
+                                if (!text.equals("")) list.add(text);
                         }
 
@@ -1344 +1429 @@
         public void setSpacing(float spacing) {
                 _spacing = spacing;
-                updatePolygon();
+                invalidateBounds();
         }
 
@@ -1356 +1441 @@
         }
 
-        private float getLineDrop(TextLayout layout) {
-                if (getSpacing() < 0)
+        /**
+         * Gets the y-distance that should be advanced between this layout and the next.
+         * 
+         * @param layout
+         *              The TextLayout to calculate line-drop for.
+         *  
+         * @return
+         *              The distance to advance in the y-direction before the next line.
+         */
+        private float getLineDrop(TextLayout layout)
+        {
+                if (getSpacing() < 0) {
                         return layout.getAscent() + layout.getDescent() + layout.getLeading();
+                }
 
                 return layout.getAscent() + layout.getDescent() + getSpacing();
@@ -1380 +1476 @@
         public void setLetterSpacing(float spacing) {
                 _letter_spacing = spacing;
-                HashMap<TextAttribute, Object> attr = new HashMap<TextAttribute, Object>();
-                attr.put(TextAttribute.TRACKING, spacing);
-
-                if (this._font == null) {
-                        this._font = Font.decode(DEFAULT_FONT);
-                }
-
-                this.setFont(this._font.deriveFont(attr));
+
+                Font currentFont = getPaintFont();
+                currentFont.setSpacing(spacing);
+                setFont(currentFont);
         }
 
@@ -1407 +1499 @@
 
         // @Override
-        public boolean intersectsOLD(Polygon p) {
+/*      public boolean intersectsOLD(Polygon p) {
                 if (super.intersects(p)) {
                         float textY = getY();
@@ -1422 +1514 @@
                 }
                 return false;
-        }
+        }*/
 
         // The following version of intersect uses a tighter definition for the text,
         // based on
         @Override
-        public boolean intersects(Polygon p) {
+        public boolean intersects(PolygonBounds p) {
                 if (super.intersects(p)) {
                         // float textY = getY();
@@ -1433 +1525 @@
                         for (TextLayout text : _textLayouts) {
 
-                                Rectangle text_pixel_bounds_rect = this.getPixelBounds(text);
+                                AxisAlignedBoxBounds text_pixel_bounds_rect = getPixelBounds(text);
 
                                 if (p.intersects(text_pixel_bounds_rect)) {
@@ -1445 +1537 @@
 
         @Override
-        public boolean contains(int mouseX, int mouseY) {
-                return contains(mouseX, mouseY, getGravity() * NEARBY_GRAVITY);
-        }
-
-        public boolean contains(int mouseX, int mouseY, int gravity) {
+        public boolean contains(Point mousePosition) {
+                return contains(mousePosition.x, mousePosition.y, getGravity() * NEARBY_GRAVITY);
+        }
+        
+        public boolean contains(int mouseX, int mouseY)
+        {
+                return contains(new Point(mouseX, mouseY));
+        }
+
+        public boolean contains(int mouseX, int mouseY, int gravity)
+        {
                 mouseX += getOffset().x;
                 mouseY += getOffset().y;
@@ -1456 +1554 @@
                 float textX = getX();
 
-                Rectangle2D outline = getPolygon().getBounds2D();
+                AxisAlignedBoxBounds outline = getBoundingBox();
+                
+                if (outline == null) return false;
 
                 // Check if its outside the top and left and bottom bounds
-                if (outline.getX() - mouseX > gravity || outline.getY() - mouseY > gravity
-                                || mouseY - (outline.getY() + outline.getHeight()) > gravity
-                                || mouseX - (outline.getX() + outline.getWidth()) > gravity) {
+                if (outline.getMinX() - mouseX > gravity
+                                || outline.getMinY() - mouseY > gravity
+                                || mouseY - (outline.getMinY() + outline.getHeight()) > gravity
+                                || mouseX - (outline.getMinX() + outline.getWidth()) > gravity) {
                         return false;
                 }
@@ -1467 +1568 @@
                 for (TextLayout text : _textLayouts) {
                         // check left and right of each box
-                        Rectangle2D textOutline = text.getLogicalHighlightShape(0, text.getCharacterCount()).getBounds2D();
+                        AxisAlignedBoxBounds textOutline = text.getLogicalHighlightShape(0, text.getCharacterCount());
 
                         // check if the cursor is within the top, bottom and within the
@@ -1473 +1574 @@
                         int justOffset = getJustOffset(text);
 
-                        if (mouseY - textY > textOutline.getY() && mouseY - textY < textOutline.getY() + textOutline.getHeight()
-                                        && mouseX - textX - justOffset < textOutline.getWidth() + gravity + Item.MARGIN_RIGHT
-                        /* &&(justOffset == 0 || mouseX > textX + justOffset - gravity ) */)
+                        if (mouseY - textY > textOutline.getMinY() &&
+                                        mouseY - textY < textOutline.getMinY() + textOutline.getHeight() &&
+                                        mouseX - textX - justOffset < textOutline.getWidth() + gravity + Item.MARGIN_RIGHT)
+                        {
                                 return true;
+                        }
+                        
                         textY += getLineDrop(text);
                 }
@@ -1486 +1590 @@
          * Updates the Polygon (rectangle) that surrounds this Text on the screen.
          */
-        public void updatePolygon() {
+        public AxisAlignedBoxBounds updateBounds()
+        {
                 // if there is no text, there is nothing to do
-                if (_text == null)
-                        return;
+                if (_text == null) return null;
+
+                if (_textLayouts == null || _textLayouts.size() < 1) return null;
 
                 int preChangeWidth = 0;
-                if (_poly != null)
-                        preChangeWidth = _poly.getBounds().width;
-
-                _poly = new Polygon();
-
-                if (_textLayouts.size() < 1)
-                        return;
+                if (getOldBounds() != null) {
+                        preChangeWidth = AxisAlignedBoxBounds.getEnclosing(getOldBounds()).getWidth();
+                }
 
                 int minX = Integer.MAX_VALUE;
@@ -1515 +1617 @@
 
                 for (TextLayout layout : tmpTextLayouts) {
-                        Rectangle2D bounds = layout.getLogicalHighlightShape(0, layout.getCharacterCount()).getBounds2D();
+                        AxisAlignedBoxBounds bounds = layout.getLogicalHighlightShape(0, layout.getCharacterCount());
 
                         if (y < 0)
@@ -1536 +1638 @@
                 }
 
-                _poly.addPoint(minX - getGravity(), minY - getGravity());
-                _poly.addPoint(maxX + getGravity(), minY - getGravity());
-                _poly.addPoint(maxX + getGravity(), maxY + getGravity());
-                _poly.addPoint(minX - getGravity(), maxY + getGravity());
-
-                _poly.translate(getX(), getY());
-
-                if (preChangeWidth != 0 && preChangeWidth != _poly.getBounds().width)
-                        if (_poly.getBounds().width > preChangeWidth)
-                                MagneticConstraints.getInstance().textGrown(this, _poly.getBounds().width - preChangeWidth);
-                        else
-                                MagneticConstraints.getInstance().textShrunk(this, preChangeWidth - _poly.getBounds().width);
-        }
-
-        // TODO it seems like this method has some exponencial processing which
+                AxisAlignedBoxBounds ret = new AxisAlignedBoxBounds(getX() + minX - getGravity(),
+                                                                                                                        getY() + minY - getGravity(),
+                                                                                                                        2 * getGravity() + maxX - minX,
+                                                                                                                        2 * getGravity() + maxY - minY);
+                
+                Dimension polySize = ret.getSize();
+                                                
+                if(preChangeWidth != 0 && preChangeWidth != polySize.width) {
+                        if (polySize.width > preChangeWidth) {
+                                MagneticConstraints.getInstance().textGrown(this, polySize.width - preChangeWidth);
+                        } else {
+                                MagneticConstraints.getInstance().textShrunk(this, preChangeWidth - polySize.width);
+                        }
+                }
+                
+                return ret;
+        }
+
+        // TODO it seems like this method has some exponential processing which
         // makes items copy really slowly when there are lots of lines of text!
         // This needs to be fixed!!
@@ -1564 +1670 @@
          */
         private void rebuild(boolean limitWidth, boolean newLinebreakerAlways) {
-                // TODO make this more efficient so it only clears annotation list when
-                // it really has to
+                // TODO make this more efficient so it only clears annotation list when it really has to
                 if (isAnnotation()) {
                         Frame parent = getParent();
@@ -1582 +1687 @@
                 }
 
-                if (_lineBreaker == null || newLinebreakerAlways) {
-                        AttributedString paragraphText = new AttributedString(_text.toString());
-                        paragraphText.addAttribute(TextAttribute.FONT, getPaintFont());
-                        frc = new FontRenderContext(null, true, true);
-                        _lineBreaker = new LineBreakMeasurer(paragraphText.getIterator(), frc);
-                }
-
-                /*
-                 * float width = Float.MAX_VALUE;
-                 * 
-                 * if (limitWidth) { width = getAbsoluteWidth(); // else if (getMaxWidth() > 0)
-                 * // width = Math.max(50, getMaxWidth() - getX() // - Item.MARGIN_RIGHT); }
-                 */
-
-                _textLayouts.clear();
-                _lineOffsets.clear();
-                // the first line always has a 0 offset
-                _lineOffsets.add(0);
-
-                TextLayout layout;
-
-                float width;
-                float lineHeight = Float.NaN;
-                List<Point[]> lines = null;
-
-                if (_autoWrap || ExperimentalFeatures.AutoWrap.get()) {
-                        lines = new LinkedList<Point[]>();
-                        if (DisplayIO.getCurrentFrame() == null) {
-                                return;
-                        }
-                        for (Item item : DisplayIO.getCurrentFrame().getItems()) {
-                                if (item instanceof Line) {
-                                        lines.add(new Point[] { ((Line) item).getStartItem().getPosition(),
-                                                        ((Line) item).getEndItem().getPosition() });
-                                }
-                                if (item instanceof Picture) {
-                                        lines.add(
-                                                        new Point[] { item.getPosition(), new Point(item.getX(), item.getY() + item.getHeight()) });
-                                }
-                        }
-                        for (Item item : FreeItems.getInstance()) {
-                                if (item instanceof Line) {
-                                        lines.add(new Point[] { ((Line) item).getStartItem().getPosition(),
-                                                        ((Line) item).getEndItem().getPosition() });
-                                }
-                                if (item instanceof Picture) {
-                                        lines.add(
-                                                        new Point[] { item.getPosition(), new Point(item.getX(), item.getY() + item.getHeight()) });
-                                }
-                        }
-                        width = getLineWidth(getX(), getY(), lines);
-                } else {
-                        width = Float.MAX_VALUE;
-                        if (limitWidth) {
-                                if (_maxWidth == null) {
-                                        width = FrameGraphics.getMaxFrameSize().width - getX();
-                                } else {
-                                        width = getAbsoluteWidth();
-                                }
-                                // else if (getMaxWidth() > 0)
-                                // width = Math.max(50, getMaxWidth() - getX()
-                                // - Item.MARGIN_RIGHT);
-                        }
-                }
-
-                _lineBreaker.setPosition(0);
-                boolean requireNextWord = false;
-
-                // --- Get the output of the LineBreakMeasurer and store it in a
-                while (_lineBreaker.getPosition() < _text.length()) {
-
-                        if (_autoWrap || ExperimentalFeatures.AutoWrap.get()) {
-                                requireNextWord = width < FrameGraphics.getMaxFrameSize().width - getX();
-                        }
-
-                        layout = _lineBreaker.nextLayout(width, _text.length(), requireNextWord);
-
-                        // lineBreaker does not break on newline
-                        // characters so they have to be check manually
-                        int start = _lineOffsets.get(_lineOffsets.size() - 1);
-
-                        // int y = getY() + (getLineDrop(layout) * (_lineOffsets.size() - 1)
-
-                        // check through the current line for newline characters
-                        for (int i = start + 1; i < _text.length(); i++) {
-                                if (_text.charAt(i) == '\n') {// || c == '\t'){
-                                        _lineBreaker.setPosition(start);
-                                        layout = _lineBreaker.nextLayout(width, i, requireNextWord);
-                                        break;
-                                }
-                        }
-
-                        _lineOffsets.add(_lineBreaker.getPosition());
-
-                        if (layout == null) {
-                                layout = new TextLayout(" ", getPaintFont(), frc);
-                        }
-
-                        if (/* hasWidth() && */getJustification() == Justification.full
-                                        && _lineBreaker.getPosition() < _text.length())
-                                layout = layout.getJustifiedLayout(width);
-
-                        _textLayouts.add(layout);
-
-                        if (_autoWrap || ExperimentalFeatures.AutoWrap.get()) {
-
-                                if (lineHeight != Float.NaN) {
-                                        lineHeight = getLineDrop(layout);
-                                }
-                                width = getLineWidth(getX(), getY() + (lineHeight * (_textLayouts.size() - 1)), lines);
-                        }
-                }
-
-                updatePolygon();
-
-        }
-
-        private float getLineWidth(int x, float y, List<Point[]> lines) {
+                EcosystemManager.getTextLayoutManager().releaseLayouts(_textLayouts);
+                if (_textLayouts != null) _textLayouts.clear();
+
+                // Calculate the maximum allowable width of this line of text
+                List<org.expeditee.core.Line> lines = null;
+                if(_autoWrap || ExperimentalFeatures.AutoWrap.get()) {
+                        lines = new LinkedList<org.expeditee.core.Line>();
+                if(DisplayController.getCurrentFrame() == null) {
+                        return;
+                }
+                for(Item item : DisplayController.getCurrentFrame().getItems()) {
+                                if(item instanceof Line) {
+                                        lines.add(new org.expeditee.core.Line (((Line) item).getStartItem().getPosition(), ((Line) item).getEndItem().getPosition()));
+                                }
+                                if(item instanceof Picture) {
+                                        lines.add(new org.expeditee.core.Line(item.getPosition(), new Point(item.getX(), item.getY() + item.getHeight())));
+                                }
+                }
+                for(Item item : FreeItems.getInstance()) {
+                                if(item instanceof Line) {
+                                        lines.add(new org.expeditee.core.Line(((Line) item).getStartItem().getPosition(), ((Line) item).getEndItem().getPosition()));
+                                }
+                                if(item instanceof Picture) {
+                                        lines.add(new org.expeditee.core.Line(item.getPosition(), new Point(item.getX(), item.getY() + item.getHeight())));
+                                }
+                }
+                }
+
+                float width = Float.MAX_VALUE;
+                if (limitWidth) {
+                        if(_maxWidth == null) {
+                                width = DisplayController.getFramePaintArea().getWidth() - getX();
+                        } else {
+                                width = getAbsoluteWidth();
+                        }
+                }
+                
+                _textLayouts = EcosystemManager.getTextLayoutManager().layoutString(_text.toString(),
+                                                                                                                                        getPaintFont(),
+                                                                                                                                        new Point(getX(), getY()),
+                                                                                                                                        lines != null ? lines.toArray(new org.expeditee.core.Line[1]) : null,
+                                                                                                                                        (int) width,
+                                                                                                                                        (int) getSpacing(),
+                                                                                                                                        true,
+                                                                                                                                        getJustification() == Justification.full);
+
+                invalidateBounds();
+
+        }
+
+        /**
+         * Calculates the maximum possible distance a line can extend to the right from a given (x,y) point
+         * without crossing any of the lines in the given list.
+         * 
+         * @param x
+         *              The x-coordinate of the beginning point.
+         * 
+         * @param y
+         *              The y-coordinate of the beginning point.
+         * 
+         * @param lines
+         *              A list of pairs of points describing the lines that should stop the extension.
+         * 
+         * @return
+         *              The length of the extended line.
+         */
+/*      private float getLineWidth(int x, float y, List<Point[]> lines) {
                 float width = FrameGraphics.getMaxFrameSize().width;
                 for (Point[] l : lines) {
@@ -1725 +1779 @@
                 }
                 return width - x;
-        }
+        }*/
 
         private boolean hasFixedWidth() {
@@ -1741 +1795 @@
         }
 
-        private Point getSelectedRange(int line) {
+        private Range<Integer> getSelectedRange(int line) {
                 if (_selectionEnd >= _text.length()) {
                         _selectionEnd = _text.length();
@@ -1756 +1810 @@
 
                 // if the selection is after this line, return null
-                if (_lineOffsets.get(line) > selectionRight)
-                        return null;
+                if (_textLayouts.get(line).getStartCharIndex() > selectionRight) return null;
 
                 // if the selection is before this line, return null
-                if (_lineOffsets.get(line) < selectionLeft
-                                && _lineOffsets.get(line) + _textLayouts.get(line).getCharacterCount() < selectionLeft)
-                        return null;
+                if (_textLayouts.get(line).getEndCharIndex() < selectionLeft) return null;
 
                 // Dont highlight a single char
@@ -1770 +1821 @@
                 // the selection occurs on this line, determine where it lies on the
                 // line
-                int start = Math.max(0, selectionLeft - _lineOffsets.get(line));
+                int start = Math.max(0, selectionLeft - _textLayouts.get(line).getStartCharIndex());
                 // int end = Math.min(_lineOffsets.get(line) +
                 // _textLayouts.get(line).getCharacterCount(), _selectionEnd);
-                int end = Math.min(selectionRight - _lineOffsets.get(line), +_textLayouts.get(line).getCharacterCount());
+                int end = Math.min(selectionRight - _textLayouts.get(line).getStartCharIndex(), _textLayouts.get(line).getCharacterCount());
 
                 // System.out.println(line + ": " + start + "x" + end + " (" +
                 // _selectionStart + "x" + _selectionEnd + ")");
-                return new Point(start, end);
-        }
-
-        /**
-         * @param mouseButton
-         *            Either MouseEvent.BUTTON1, MouseEvent.BUTTON2 or
-         *            MouseEvent.BUTTON3.
-         * 
-         * @return The color for the text selection based on the given mouse click
-         */
-        protected Color getSelectionColor(int mouseButton) {
-
-                /*
-                 * Color main = getPaintColor(); Color back = getPaintBackgroundColor();
-                 * 
-                 * if (Math.abs(main.getRed() - back.getRed()) < 10 && Math.abs(main.getGreen()
-                 * - back.getGreen()) < 10 && Math.abs(main.getBlue() - back.getBlue()) < 10) {
-                 * selection = new Color(Math.abs(255 - main.getRed()), Math .abs(255 -
-                 * main.getGreen()), Math.abs(255 - main.getBlue())); } else { selection = new
-                 * Color((main.getRed() + (back.getRed() * 2)) / 3, (main.getGreen() +
-                 * (back.getGreen() * 2)) / 3, (main .getBlue() + (back.getBlue() * 2)) / 3); }
-                 */
-                int green = 160;
-                int red = 160;
-                int blue = 160;
-
-                if (FrameMouseActions.wasDeleteClicked()) {
-                        green = 235;
-                        red = 235;
-                        blue = 140;
-                } else if (mouseButton == MouseEvent.BUTTON1) {
-                        red = 255;
-                } else if (mouseButton == MouseEvent.BUTTON2) {
-                        green = 255;
-                } else if (mouseButton == MouseEvent.BUTTON3) {
-                        blue = 255;
-                }
-
-                return new Color(red, green, blue);
+                return new Range<Integer>(start, end, true, true);
+        }
+
+        /** Sets the colour that should be used to render the selected range. */
+        public void setSelectionColour(Colour colour)
+        {
+                if (colour == null) colour = RANGE_SELECT_COLOUR;
+                
+                _selectionColour = colour;
+        }
+        
+        /** Gets the colour that should be used to render the selected range. */
+        public Colour getSelectionColour()
+        {
+                return _selectionColour;
         }
 
         @Override
-        public void paint(Graphics2D g) {
-                if (!isVisible())
-                        return;
+        public void paint()
+        {
+                if (!isVisible()) return;
 
                 // if there is no text to paint, do nothing.
-                if (_text == null || _text.length() == 0)
-                        return;
+                if (_text == null || _text.length() == 0) return;
 
                 if (_autoWrap || ExperimentalFeatures.AutoWrap.get()) {
@@ -1841 +1867 @@
                 // This will allow for dragging vectors around the place!
                 if (hasVector() && isFloating()) {
-                        FrameGraphics.requestRefresh(false);
+                        DisplayController.requestRefresh(false);
                         // TODO make this use a more efficient paint method...
                         // Have the text item return a bigger repaint area if it has an
                         // associated vector
                 }
+                
+                GraphicsManager g = EcosystemManager.getGraphicsManager();
+                AxisAlignedBoxBounds bounds = (AxisAlignedBoxBounds) getBounds();
 
                 // the background is only cleared if required
                 if (getBackgroundColor() != null) {
-                        Color bgc = getBackgroundColor();
+                        Colour bgc = getBackgroundColor();
                         if (_alpha > 0) {
-                                bgc = new Color(bgc.getRed(), bgc.getGreen(), bgc.getBlue(), _alpha);
-                        }
-                        g.setColor(bgc);
-
-                        Color gradientColor = getGradientColor();
-                        if (gradientColor != null) {
-                                // The painting is not efficient enough for gradients...
-                                Shape s = getPolygon();
-                                if (s != null) {
-                                        Rectangle b = s.getBounds();
-                                        GradientPaint gp = new GradientPaint((int) (b.x + b.width * 0.3), b.y, bgc,
-                                                        (int) (b.x + b.width * 1.3), b.y, gradientColor);
-                                        g.setPaint(gp);
-                                }
-                        }
-
-                        g.fillPolygon(getPolygon());
+                                bgc = new Colour(bgc.getRed(), bgc.getGreen(), bgc.getBlue(),
+                                                Colour.FromComponent255(_alpha));
+                        }
+
+                        Colour gradientColor = getGradientColor();
+                        
+                        Fill fill;
+                        
+                        if (gradientColor != null && bounds != null) {
+                                fill = new GradientFill(bgc, new Point((int) (bounds.getMinX() + bounds.getWidth() * 0.3), bounds.getMinY()), gradientColor, new Point((int) (bounds.getMinX() + bounds.getWidth() * 1.3), bounds.getMinY()));
+                        } else {
+                                fill = new Fill(bgc);
+                        }
+
+                        g.drawRectangle(bounds, 0.0, fill, null, null, null);
                 }
 
                 if (hasVisibleBorder()) {
-                        g.setColor(getPaintBorderColor());
-                        Stroke borderStroke = new BasicStroke(getThickness(), CAP, JOIN);
-                        g.setStroke(borderStroke);
-                        g.drawPolygon(getPolygon());
+                        Stroke borderStroke = new Stroke(getThickness(), DEFAULT_CAP, DEFAULT_JOIN);
+                        g.drawRectangle(bounds, 0.0, null, getPaintBorderColor(), borderStroke, null);
                 }
 
                 if (hasFormula()) {
-                        g.setColor(getPaintHighlightColor());
-                        Stroke highlightStroke = new BasicStroke(1F, CAP, JOIN);
-                        g.setStroke(highlightStroke);
-
-                        Point2D.Float start = getEdgePosition(0, true);
-                        Point2D.Float end = getEdgePosition(0, false);
-                        g.drawLine(Math.round(start.x), Math.round(start.y), Math.round(end.x), Math.round(end.y));
+                        Stroke highlightStroke = new Stroke(1F, DEFAULT_CAP, DEFAULT_JOIN);
+                        Point start = getEdgePosition(0, true);
+                        Point end = getEdgePosition(0, false);
+                        g.drawLine(start, end, getPaintHighlightColor(), highlightStroke);
                 }
 
                 if (isHighlighted()) {
-                        g.setColor(getPaintHighlightColor());
-                        Stroke highlightStroke = new BasicStroke((float) getHighlightThickness(), CAP, JOIN);
-                        g.setStroke(highlightStroke);
-                        if (HighlightMode.Enclosed.equals(getHighlightMode()))
-                                g.fillPolygon(getPolygon());
-                        else
-                                g.drawPolygon(getPolygon());
+                        Stroke highlightStroke = new Stroke((float) getHighlightThickness(), DEFAULT_CAP, DEFAULT_JOIN);
+                        Fill fill;
+                        if (HighlightMode.Enclosed.equals(getHighlightMode())) {
+                                fill = new Fill(getPaintHighlightColor());
+                        } else {
+                                fill = null;
+                        }
+                        g.drawRectangle(bounds, 0.0, fill, getPaintHighlightColor(), highlightStroke, null);
                 }
 
                 float y = getY();
-                Color c = getPaintColor();
-                if (_alpha > 0)
-                        c = new Color(c.getRed(), c.getGreen(), c.getBlue(), _alpha);
-
-                g.setColor(c);
-
-                Color selection = getSelectionColor(FrameMouseActions.getLastMouseButton());
+                Colour paintColour = getPaintColor();
+                if (_alpha > 0) {
+                        paintColour = new Colour(paintColour);
+                        paintColour.setAlpha(Colour.FromComponent255(_alpha));
+                        
+                }
+
+                Colour selectionColour = getSelectionColour();
 
                 // width -= getX();
@@ -1913 +1937 @@
                                 TextLayout layout = _textLayouts.get(i);
 
-                                Point p = getSelectedRange(i);
-                                if (p != null) {
-                                        AffineTransform at = new AffineTransform();
-                                        AffineTransform orig = g.getTransform();
-                                        at.translate(getX() + getJustOffset(layout), y);
-                                        g.setTransform(at);
-
-                                        g.setColor(selection);
-                                        g.fill(layout.getLogicalHighlightShape(p.x, p.y));
-
-                                        g.setTransform(orig);
-                                        g.setColor(c);
+                                Range<Integer> selectedRange = getSelectedRange(i);
+                                if (selectedRange != null) {
+                                        AxisAlignedBoxBounds highlight = layout.getLogicalHighlightShape(selectedRange.lowerBound, selectedRange.upperBound);
+                                        highlight.getTopLeft().add(getX() + getJustOffset(layout), (int) y);
+                                        g.drawRectangle(highlight,
+                                                                        0.0,
+                                                                        new Fill(selectionColour),
+                                                                        null, null, null);
                                 }
 
                                 int ldx = 1 + getX() + getJustOffset(layout); // Layout draw x
 
-                                boolean debug = false;
-                                if (debug) {
-                                        g.setColor(new Color(c.getRed(), c.getGreen(), c.getBlue(), 40));
-                                        Rectangle layout_rect = layout.getPixelBounds(null, ldx, y);
-                                        g.fillRect(layout_rect.x, layout_rect.y, layout_rect.width, layout_rect.height);
-                                        g.setColor(c);
-                                }
-
-                                layout.draw(g, ldx, y);
-
-                                /*
-                                 * AffineTransform at = new AffineTransform(); AffineTransform orig =
-                                 * g.getTransform(); at.translate(getX() + getJustOffset(layout), y);
-                                 * g.setTransform(at); g.draw(layout.getLogicalHighlightShape(0,
-                                 * layout.getCharacterCount())); g.setTransform(orig); /*
-                                 * if(_text.charAt(_lineOffsets.get(line) + (layout.getCharacterCount() - 1)) ==
-                                 * '\t'){ tab = true; x = (int) (getX() + x + 20 + layout.getVisibleAdvance());
-                                 * }else{
-                                 */
+                                g.drawTextLayout(layout, new Point(ldx, (int) y), paintColour);
+
                                 y += getLineDrop(layout);
-                                /*
-                                 * tab = false; }
-                                 * 
-                                 * line++;
-                                 */
-                        }
-                }
-
-                paintLink(g);
-        }
-
+                        }
+                }
+
+                paintLink();
+        }
+
+        // TODO: Revise
         @Override
-        protected Rectangle getLinkDrawArea() { // TODO: Revise
-                return getDrawingArea()[0];
+        protected AxisAlignedBoxBounds getLinkDrawArea()
+        {
+                return getDrawingArea();
         }
 
@@ -1970 +1970 @@
          * @return True if this Item has no text in it, false otherwise.
          */
-        public boolean isEmpty() {
-                if (_text == null || _text.length() == 0)
-                        return true;
-
-                return false;
+        public boolean isEmpty()
+        {
+                return (_text == null || _text.length() == 0);
         }
 
@@ -2004 +2002 @@
         @Override
         public float getSize() {
-                return getPaintFont().getSize2D();
+                return getPaintFont().getSize();
         }
 
@@ -2026 +2024 @@
                 if (size < MINIMUM_FONT_SIZE)
                         size = MINIMUM_FONT_SIZE;
-                setFont(getPaintFont().deriveFont(size));
+                Font currentFont = getPaintFont();
+                currentFont.setSize((int) size);
+                setFont(currentFont);
                 rebuild(true);
                 invalidateAll();
@@ -2033 +2033 @@
         @Override
         public void setAnnotation(boolean val) {
-                float mouseX = DisplayIO.getFloatMouseX();
-                float mouseY = FrameMouseActions.MouseY;
-                Point2D.Float newPoint = new Point2D.Float();
+                float mouseX = DisplayController.getFloatMouseX();
+                float mouseY = DisplayController.getFloatMouseY();
+                Point newPoint = new Point();
                 if (val) {
                         // if this is already an annotation, do nothing
@@ -2041 +2041 @@
                                 return;
                         if (!isLineEnd() && _text.length() > 0 && _text.charAt(0) == DEFAULT_BULLET) {
-                                newPoint.setLocation(insertText("" + (char) KeyEvent.VK_BACK_SPACE, mouseX, mouseY, 1));
+                                newPoint.set(insertText("\b", mouseX, mouseY, 1));
                                 if (_text.length() > 0 && _text.charAt(0) == ' ')
-                                        newPoint.setLocation(insertText("" + (char) KeyEvent.VK_BACK_SPACE, newPoint.x, newPoint.y, 1));
+                                        newPoint.set(insertText("\b", newPoint.x, newPoint.y, 1));
                         } else {
-                                newPoint.setLocation(insertText("@", mouseX, mouseY, 0));
+                                newPoint.set(insertText("@", mouseX, mouseY, 0));
                         }
                 } else {
@@ -2052 +2052 @@
                                 return;
                         if (!isLineEnd() && _text.charAt(0) == '@') {
-                                newPoint.setLocation(insertText("" + (char) KeyEvent.VK_BACK_SPACE, mouseX, mouseY, 1));
-                                newPoint.setLocation(insertText(DEFAULT_BULLET_STRING, newPoint.x, newPoint.y, 0));
+                                newPoint.set(insertText("\b", mouseX, mouseY, 1));
+                                newPoint.set(insertText(DEFAULT_BULLET_STRING, newPoint.x, newPoint.y, 0));
                         } else {
-                                newPoint.setLocation(insertText("" + (char) KeyEvent.VK_BACK_SPACE, mouseX, mouseY, 1));
+                                newPoint.set(insertText("\b", mouseX, mouseY, 1));
                         }
                 }
                 FrameUtils.setLastEdited(this);
                 rebuild(true);
-                DisplayIO.setCursorPosition(newPoint.x, newPoint.y, false);
+                DisplayController.setCursorPosition(newPoint.x, newPoint.y, false);
         }
 
@@ -2068 +2068 @@
         private void insertString(String toInsert, int pos) {
                 assert (toInsert.length() > 0);
-
+                invalidateAll();
                 _text.insert(pos, toInsert);
-
-                if (toInsert.length() > 1) {
-                        _lineBreaker = null;
-                }
-
-                if (_lineBreaker != null) {
-                        AttributedString inserting = new AttributedString(_text.toString());
-                        inserting.addAttribute(TextAttribute.FONT, getPaintFont());
-                        _lineBreaker.insertChar(inserting.getIterator(), pos);
-                }
+                rebuild(false);
+                invalidateAll();
         }
 
@@ -2088 +2080 @@
                         if (this.isLineEnd()) {
                                 // Remove and replace with a dot
-                                FrameKeyboardActions.replaceText(this);
-                                DisplayIO.setCursorPosition(this._x, this._y);
+                                Item.replaceText(this);
+                                DisplayController.setCursorPosition(this._x, this._y);
                         }
                         return;
-                }
-
-                if (_lineBreaker != null) {
-                        AttributedString inserting = new AttributedString(_text.toString());
-                        inserting.addAttribute(TextAttribute.FONT, getPaintFont());
-                        _lineBreaker.deleteChar(inserting.getIterator(), pos);
                 }
 
@@ -2229 +2215 @@
         }
 
+        /**
+         * Checks if the given point is 'near' any line of the text item.
+         */
         @Override
         public boolean isNear(int x, int y) {
@@ -2242 +2231 @@
                         for (TextLayout text : _textLayouts) {
                                 // check left and right of each box
-                                Rectangle2D textOutline = text.getLogicalHighlightShape(0, text.getCharacterCount()).getBounds2D();
+                                AxisAlignedBoxBounds textOutline = text.getLogicalHighlightShape(0, text.getCharacterCount());
 
                                 // check if the cursor is within the top, bottom and within the
                                 // gravity of right
-                                if (y - textY > textOutline.getY() - NEAR_DISTANCE
-                                                && y - textY < textOutline.getY() + textOutline.getHeight() + NEAR_DISTANCE
-                                                && x - textX < textOutline.getWidth() + NEAR_DISTANCE)
+                                if (y - textY > textOutline.getMinY() - NEAR_DISTANCE &&
+                                        y - textY < textOutline.getMinY() + textOutline.getHeight() + NEAR_DISTANCE &&
+                                        x - textX < textOutline.getWidth() + NEAR_DISTANCE)
+                                {
                                         return true;
+                                }
+                                
                                 textY += getLineDrop(text);
                         }
@@ -2263 +2255 @@
                 setAlpha(0);
                 if (isLineEnd())
-                        DisplayIO.setCursor(Item.DEFAULT_CURSOR);
+                        DisplayController.setCursor(Item.DEFAULT_CURSOR);
 
                 String text = _text.toString().trim();
@@ -2271 +2263 @@
                 // Show the overlay stuff immediately if this is an overlay item
                 if (hasLink() && (text.startsWith("@ao") || text.startsWith("@o"))) {
-                        FrameKeyboardActions.Refresh();
+                        StandardGestureActions.Refresh();
                 }
         }
@@ -2277 +2269 @@
         private void clipFrameMargin() {
                 if (!hasFixedWidth()) {
-                        int frameWidth = FrameGraphics.getMaxFrameSize().width;
+                        int frameWidth = DisplayController.getFramePaintArea().getWidth();
                         /*
                          * Only change width if it is more than 150 pixels from the right of the screen
@@ -2292 +2284 @@
         }
 
-        public void justify(boolean fixWidth, Polygon enclosure) {
+        public void justify(boolean fixWidth, PolygonBounds enclosure) {
                 // if autowrap is on, wrapping is done every time we draw
-                if (ExperimentalFeatures.AutoWrap.get()) {
-                        return;
-                }
-
-                Integer width = FrameGraphics.getMaxFrameSize().width;
+                if(ExperimentalFeatures.AutoWrap.get()) return;
+
+                Integer width = DisplayController.getFramePaintArea().getWidth();
 
                 // Check if that text item is inside an enclosing rectangle...
                 // Set its max width accordingly
                 if (enclosure != null) {
-                        Rectangle bounds = enclosure.getBounds();
-                        if (bounds.width > 200 && getX() < bounds.width / 3 + bounds.x) {
-                                width = bounds.x + bounds.width;
-                        }
-                }
-
-                if (getWidth() == null)
-                        setRightMargin(width, fixWidth);
-
-                // Check for the annotation that restricts the width of text items
-                // on the frame
+                        AxisAlignedBoxBounds bounds = AxisAlignedBoxBounds.getEnclosing(enclosure);
+                        if (bounds.getWidth() > 200 && getX() < bounds.getWidth() / 3 + bounds.getMinX()) {
+                                width = bounds.getMinX() + bounds.getWidth();
+                        }
+                }
+
+                if (getWidth() == null) setRightMargin(width, fixWidth);
+
+                // Check for the annotation that restricts the width of text items on the frame
                 String widthString;
                 if ((widthString = getParentOrCurrentFrame().getAnnotationValue("maxwidth")) != null) {
@@ -2329 +2317 @@
         public void justify(boolean fixWidth) {
                 // if autowrap is on, wrapping is done every time we draw
-                if (ExperimentalFeatures.AutoWrap.get()) {
-                        return;
-                }
+                if(ExperimentalFeatures.AutoWrap.get()) return;
+
                 this.justify(fixWidth, FrameUtils.getEnlosingPolygon());
         }
 
         public void resetFrameNamePosition() {
-                Dimension maxSize = FrameGraphics.getMaxFrameSize();
+                Dimension maxSize = DisplayController.getFramePaintArea().getSize();
                 if (maxSize != null) {
                         // setMaxWidth(maxSize.width);
@@ -2357 +2344 @@
         public static final String TAB_STRING = "      ";
 
-        public Point2D.Float insertTab(char ch, float mouseX, float mouseY) {
+        public Point insertTab(char ch, float mouseX, float mouseY) {
                 return insertText("" + ch, mouseX, mouseY);
         }
 
-        public Point2D.Float removeTab(char ch, float mouseX, float mouseY) {
+        public Point removeTab(char ch, float mouseX, float mouseY) {
                 // Insert a space as a flag that it is a backwards tab
                 return insertText(ch + " ", mouseX, mouseY);
@@ -2379 +2366 @@
                 String text = getText().toLowerCase();
                 // TODO make it so can just check the _overlay variable
-                // Mike cant remember the reason _overlay var cant be use! opps
+                // Mike can't remember the reason _overlay var can't be use! oops
                 if (!text.startsWith("@"))
                         return false;
@@ -2401 +2388 @@
         @Override
         public boolean calculate(String formula) {
-                if (FrameGraphics.isXRayMode())
+                if (DisplayController.isXRayMode())
                         return false;
 
@@ -2553 +2540 @@
 
         @Override
-        public void setAnchorLeft(Float anchor) {
+        public void setAnchorLeft(Integer anchor) {
                 if (!isLineEnd()) {
                         super.setAnchorLeft(anchor);
@@ -2565 +2552 @@
                 invalidateCommonTrait(ItemAppearence.PreMoved);
 
-                this._anchorLeft = anchor;
-                this._anchorRight = null;
+                this._anchoring.setLeftAnchor(anchor);
 
                 int oldX = getX();
@@ -2579 +2565 @@
 
         @Override
-        public void setAnchorRight(Float anchor) {
+        public void setAnchorRight(Integer anchor) {
                 if (!isLineEnd()) {
                         super.setAnchorRight(anchor);
                         // Subtract off the link width
                         if (anchor != null) {
-                                setX(FrameGraphics.getMaxFrameSize().width - anchor - getBoundsWidth() + getLeftMargin());
+                                setX(DisplayController.getFramePaintArea().getWidth() - anchor
+                                                - getBoundsWidth() + getLeftMargin());
                         }
                         return;
@@ -2591 +2578 @@
                 invalidateCommonTrait(ItemAppearence.PreMoved);
 
-                this._anchorRight = anchor;
-                this._anchorLeft = null;
+                this._anchoring.setRightAnchor(anchor);
 
                 int oldX = getX();
                 if (anchor != null) {
-                        float deltaX = FrameGraphics.getMaxFrameSize().width - anchor - getBoundsWidth() + getLeftMargin() - oldX;
+                        float deltaX = DisplayController.getFramePaintArea().getWidth() - anchor
+                                        - getBoundsWidth() + getLeftMargin() - oldX;
                         anchorConnected(AnchorEdgeType.Right, deltaX);
                 }
@@ -2605 +2592 @@
 
         @Override
-        public void setAnchorTop(Float anchor) {
+        public void setAnchorTop(Integer anchor) {
                 if (!isLineEnd()) {
                         super.setAnchorTop(anchor);
@@ -2616 +2603 @@
                 invalidateCommonTrait(ItemAppearence.PreMoved);
 
-                this._anchorTop = anchor;
-                this._anchorBottom = null;
+                this._anchoring.setTopAnchor(anchor);
 
                 int oldY = getY();
@@ -2630 +2616 @@
 
         @Override
-        public void setAnchorBottom(Float anchor) {
+        public void setAnchorBottom(Integer anchor) {
                 if (!isLineEnd()) {
                         super.setAnchorBottom(anchor);
                         if (anchor != null) {
-                                setY(FrameGraphics.getMaxFrameSize().height - (anchor + this.getBoundsHeight()
-                                                - _textLayouts.get(0).getAscent() - _textLayouts.get(0).getDescent()));
+                                setY(DisplayController.getFramePaintArea().getHeight() - (anchor + this.getBoundsHeight() - _textLayouts.get(0).getAscent() - _textLayouts.get(0).getDescent()));
                         }
                         return;
@@ -2642 +2627 @@
                 invalidateCommonTrait(ItemAppearence.PreMoved);
 
-                this._anchorBottom = anchor;
-                this._anchorTop = null;
+                this._anchoring.setBottomAnchor(anchor);
 
                 int oldY = getY();
                 if (anchor != null) {
 
-                        float deltaY = FrameGraphics.getMaxFrameSize().height - anchor - oldY;
+                        float deltaY = DisplayController.getFramePaintArea().getHeight() - anchor - oldY;
                         anchorConnected(AnchorEdgeType.Bottom, deltaY);
                 }
@@ -2669 +2653 @@
         }
 
-        protected Rectangle getPixelBounds(TextLayout layout) {
+        protected AxisAlignedBoxBounds getPixelBounds(TextLayout layout)
+        {
                 // Does 'layout' need to be synchronized (similar to _textLayouts below)??
                 int x = getX();
@@ -2675 +2660 @@
 
                 int ldx = 1 + x + getJustOffset(layout); // Layout draw x
-                Rectangle layout_rect = layout.getPixelBounds(null, ldx, y);
+                AxisAlignedBoxBounds layout_rect = layout.getPixelBounds(ldx, y);
 
                 return layout_rect;
         }
-
+        
         /**
          * Creates the smallest possible rectangle object to enclose the Text Item
@@ -2689 +2674 @@
          * @see #getPixelBoundsUnionTight()
          */
-        public Rectangle getPixelBoundsUnion() {
-                final Rectangle rect = getPixelBounds(_textLayouts.get(0));
-
-                int cumulativeHeight = rect.height;
-                int maxWidth = rect.width;
+        public AxisAlignedBoxBounds getPixelBoundsUnion()
+        {
+                final AxisAlignedBoxBounds rect = getPixelBounds(_textLayouts.get(0));
+
+                int cumulativeHeight = rect.getSize().height;
+                int maxWidth = rect.getSize().width;
 
                 if (_textLayouts.size() > 1) {
                         for (int i = 1; i < _textLayouts.size(); i++) {
-                                final Rectangle r = getPixelBounds(_textLayouts.get(i));
+                                final AxisAlignedBoxBounds r = getPixelBounds(_textLayouts.get(i));
                                 cumulativeHeight += _textLayouts.get(i).getDescent() + _textLayouts.get(i).getAscent();
-                                if (r.width > maxWidth)
-                                        maxWidth = r.width;
-                        }
-                }
-
-                rect.setSize(maxWidth, cumulativeHeight);
+                                if (r.getSize().width > maxWidth)
+                                        maxWidth = r.getSize().width;
+                        }
+                }
+                
+                rect.getSize().width = maxWidth;
+                rect.getSize().height = cumulativeHeight;
 
                 return rect;
@@ -2717 +2704 @@
          * @see #getPixelBoundsUnion()
          */
-        public Polygon getPixelBoundsUnionTight() {
-                final Rectangle rect = getPixelBounds(_textLayouts.get(0));
+        public PolygonBounds getPixelBoundsUnionTight()
+        {
+                final AxisAlignedBoxBounds rect = getPixelBounds(_textLayouts.get(0));
                 if (_textLayouts.size() == 1) {
-                        int x = (int) rect.getX();
-                        int y = (int) rect.getY();
-                        return new Polygon(new int[] { x, x + rect.width, x + rect.width, x },
-                                        new int[] { y, y, y + rect.height, y + rect.height }, 4);
+                        return PolygonBounds.fromBox(rect);
                 } else {
-                        final Polygon poly = new Polygon();
-                        poly.addPoint(rect.x, rect.y);
-                        poly.addPoint(rect.x + rect.width, rect.y);
-                        poly.addPoint(rect.x + rect.width, Math.round(rect.y + rect.height + _textLayouts.get(0).getDescent()));
-                        int y = (int) (rect.y + rect.height + _textLayouts.get(0).getDescent());
+                        final PolygonBounds poly = new PolygonBounds();
+                        poly.addPoint(rect.getMinX(), rect.getMinY());
+                        poly.addPoint(rect.getMaxX(), rect.getMinY());
+                        poly.addPoint(rect.getMaxX(), Math.round(rect.getMaxY() + _textLayouts.get(0).getDescent()));
+                        int y = (int) (rect.getMaxY() + _textLayouts.get(0).getDescent());
                         for (int i = 1; i < _textLayouts.size(); i++) {
-                                final Rectangle r = getPixelBounds(_textLayouts.get(i));
-                                poly.addPoint(r.x + r.width, y);
-                                poly.addPoint(r.x + r.width, Math.round(y + r.height + _textLayouts.get(i).getDescent()));
-                                y = Math.round(y + r.height + _textLayouts.get(i).getDescent());
-                        }
-                        poly.addPoint(rect.x + getPixelBounds(_textLayouts.get(_textLayouts.size() - 1)).width, Math.round(y + _textLayouts.get(_textLayouts.size() - 1).getDescent()));
-                        poly.addPoint(rect.x, Math.round(y + _textLayouts.get(_textLayouts.size() - 1).getDescent()));
+                                final AxisAlignedBoxBounds r = getPixelBounds(_textLayouts.get(i));
+                                poly.addPoint(r.getMaxX(), y);
+                                poly.addPoint(r.getMaxX(), Math.round(y + r.getHeight() + _textLayouts.get(i).getDescent()));
+                                y = Math.round(y + r.getHeight() + _textLayouts.get(i).getDescent());
+                        }
+                        poly.addPoint(rect.getMinX() + getPixelBounds(_textLayouts.get(_textLayouts.size() - 1)).getWidth(), Math.round(y + _textLayouts.get(_textLayouts.size() - 1).getDescent()));
+                        poly.addPoint(rect.getMinX(), Math.round(y + _textLayouts.get(_textLayouts.size() - 1).getDescent()));
                         return poly;
                 }
         }
+        
+        /*
+        public AxisAlignedBoxBounds getPixelBoundsUnion()
+        {
+                synchronized (_textLayouts) {
+                        
+                        CombinationBoxBounds c = null;
+                        
+                        for (TextLayout layout: _textLayouts) {
+                                if (c == null) {
+                                        c = new CombinationBoxBounds(getPixelBounds(layout));
+                                } else {
+                                        c.add(getPixelBounds(layout));
+                                }
+                        }
+                        
+                        return AxisAlignedBoxBounds.getEnclosing(c);
+                
+                }
+        }
+        */
 
         // public Rectangle getPixelBoundsUnion()
@@ -2809 +2815 @@
                 _autoWrap = autoWrap;
         }
+
+        /**
+         * Creates a new Text Item whose text contains the given character. This
+         * method also moves the mouse cursor to be pointing at the newly created
+         * Text Item ready to insert the next character.
+         * 
+         * @param start
+         *            The character to use as the initial text of this Item.
+         * @return The newly created Text Item
+         */
+        public static Text createText(char start) {
+                Text t = DisplayController.getCurrentFrame().createBlankText(
+                                "" + start);
+
+                Point newMouse = t.insertChar(start, DisplayController.getMouseX(), DisplayController.getMouseY());
+                DisplayController.setCursorPosition(newMouse.x, newMouse.y, false);
+
+                return t;
+        }
+
+        /**
+         * Creates a new Text Item with no text. The newly created Item is a copy of
+         * any ItemTemplate if one is present, and inherits all the attributes of
+         * the Template
+         * 
+         * @return The newly created Text Item
+         */
+        public static Text createText() {
+                return DisplayController.getCurrentFrame().createNewText();
+        }
+
+        /**
+         * If the given Item is null, then a new Text item is created with the
+         * current date. If the given Item is not null, then the current date is
+         * prepended to the Item's text
+         * 
+         * @param toAdd
+         *            The Item to prepend the date to, or null
+         */
+        public static void AddDate(Item toAdd) {
+                String date1 = Formatter.getDateTime();
+                String date2 = Formatter.getDate();
+                final String leftSeparator = " :";
+                final String rightSeparator = ": ";
+                String dateToAdd = date1 + rightSeparator;
+                boolean prepend = false;
+                boolean append = false;
+
+                // if the user is pointing at an item, add the date where ever the
+                // cursor is pointing
+                if (toAdd != null && toAdd instanceof Text) {
+                        // permission check
+                        if (!toAdd.hasPermission(UserAppliedPermission.full)) {
+                                MessageBay.displayMessage("Insufficicent permission to add the date to that item");
+                                return;
+                        }
+
+                        Text textItem = (Text) toAdd;
+
+                        String text = textItem.getText();
+
+                        // check if the default date has already been put on this item
+                        if (text.startsWith(date1 + rightSeparator)) {
+                                textItem.removeText(date1 + rightSeparator);
+                                dateToAdd = date2 + rightSeparator;
+                                prepend = true;
+                        } else if (text.startsWith(date2 + rightSeparator)) {
+                                textItem.removeText(date2 + rightSeparator);
+                                dateToAdd = leftSeparator + date2;
+                                append = true;
+                        } else if (text.endsWith(leftSeparator + date2)) {
+                                textItem.removeEndText(leftSeparator + date2);
+                                append = true;
+                                dateToAdd = leftSeparator + date1;
+                        } else if (text.endsWith(leftSeparator + date1)) {
+                                textItem.removeEndText(leftSeparator + date1);
+                                if (textItem.getLength() > 0) {
+                                        dateToAdd = "";
+                                        prepend = true;
+                                } else {
+                                        // use the default date format
+                                        prepend = true;
+                                }
+                        }
+
+                        if (prepend) {
+                                // add the date to the text item
+                                textItem.prependText(dateToAdd);
+                                if (dateToAdd.length() == textItem.getLength())
+                                        DisplayController.setCursorPosition(textItem.getParagraphEndPosition());
+                        } else if (append) {
+                                textItem.appendText(dateToAdd);
+                                if (dateToAdd.length() == textItem.getLength())
+                                        DisplayController.setCursorPosition(textItem.getPosition());
+                        } else {
+                                for (int i = 0; i < date1.length(); i++) {
+                                        StandardGestureActions.processChar(date1.charAt(i), false);
+                                }
+                        }
+
+                        textItem.getParent().setChanged(true);
+                        DisplayController.requestRefresh(true);
+                        // } else {
+                        // MessageBay
+                        // .displayMessage("Only text items can have the date prepended to
+                        // them");
+                        // }
+                        // otherwise, create a new text item
+                } else {
+                        Text newText = createText();
+                        newText.setText(dateToAdd);
+                        DisplayController.getCurrentFrame().addItem(newText);
+                        DisplayController.getCurrentFrame().setChanged(true);
+                        DisplayController.requestRefresh(true);
+
+                        DisplayController.setCursorPosition(newText.getParagraphEndPosition());
+                }
+
+        }
 }