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

Timestamp:

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

Author:

davidb

Message:

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

File:

• trunk/src/org/expeditee/items/Line.java (modified) (36 diffs)

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

@@ -19 +19 @@
 package org.expeditee.items;
 
-import java.awt.BasicStroke;
-import java.awt.Color;
-import java.awt.Graphics2D;
-import java.awt.Point;
-import java.awt.Polygon;
-import java.awt.Rectangle;
-import java.awt.RenderingHints;
-import java.awt.Shape;
-import java.awt.Stroke;
-import java.awt.geom.AffineTransform;
-import java.awt.geom.Point2D;
 import java.util.ArrayList;
 import java.util.Collection;
@@ -37 +26 @@
 import java.util.List;
 
-import org.expeditee.gui.DisplayIO;
+import org.expeditee.core.Colour;
+import org.expeditee.core.Dimension;
+import org.expeditee.core.Fill;
+import org.expeditee.core.Point;
+import org.expeditee.core.Stroke;
+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.gui.DisplayController;
 import org.expeditee.gui.Frame;
 import org.expeditee.gui.FrameGraphics;
@@ -59 +58 @@
 
         
-        public static Polygon createArrowheadPolygon(double x0, double y0, float arrowLength0, double arrowRatio0, double arrowNibPerc0) 
+        public static PolygonBounds createArrowheadPolygon(double x0, double y0, float arrowLength0, double arrowRatio0, double arrowNibPerc0) 
         {
-                
-                Polygon arrowhead = new Polygon();
+                PolygonBounds arrowhead = new PolygonBounds();
             
                 int ix0 = (int)Math.round(x0);
@@ -73 +71 @@
                 int flange_iy_left = (int) Math.round((y0 - flange_y_width));
                 int flange_iy_right = (int) Math.round((y0 + flange_y_width));
-                                
-                
-                arrowhead.addPoint(ix0, iy0);
-                arrowhead.addPoint(flange_ix_project, flange_iy_left);
-                
-                arrowhead.addPoint(ix_nib, iy0);
-                
-                arrowhead.addPoint(flange_ix_project, flange_iy_right);
+                
+                arrowhead.addPoint(new Point(ix0, iy0));
+                arrowhead.addPoint(new Point(flange_ix_project, flange_iy_left));
+                arrowhead.addPoint(new Point(ix_nib, iy0));
+                arrowhead.addPoint(new Point(flange_ix_project, flange_iy_right));
                 
                 return arrowhead;
@@ -95 +90 @@
 
         // brush strokes used for painting this line and highlighting
-        private Stroke _lineStroke = new BasicStroke(DEFAULT_THICKNESS, CAP, JOIN, 4.0F);
+        private Stroke _lineStroke = new Stroke(DEFAULT_THICKNESS, DEFAULT_CAP, DEFAULT_JOIN);
 
         Stroke getStroke() {
@@ -143 +138 @@
                         for (int i = 0; i < pattern.length; i++)
                                 dash[i] = (float) pattern[i];
-                        _lineStroke = new BasicStroke(Math.max(thick,
-                                        MINIMUM_PAINT_THICKNESS), CAP, JOIN, 10f, dash, 0.0f);
+                        _lineStroke = new Stroke(Math.max(thick, MINIMUM_PAINT_THICKNESS), DEFAULT_CAP, DEFAULT_JOIN, dash, 0.0f);
                 } else {
-                        _lineStroke = new BasicStroke(Math.max(thick,
-                                        MINIMUM_PAINT_THICKNESS), CAP, JOIN);
-                }
-
-                updatePolygon();
+                        _lineStroke = new Stroke(Math.max(thick, MINIMUM_PAINT_THICKNESS), DEFAULT_CAP, DEFAULT_JOIN);
+                }
+
+                invalidateBounds();
         }
 
@@ -240 +233 @@
                         _start = start;
                         _start.addLine(this);
-                        updatePolygon();
+                        invalidateBounds();
                 }
         }
@@ -258 +251 @@
                         _end = end;
                         _end.addLine(this);
-                        updatePolygon();
+                        invalidateBounds();
                 }
         }
@@ -317 +310 @@
                         for (int i = 0; i < pattern.length; i++)
                                 dash[i] = (float) pattern[i];
-                        _lineStroke = new BasicStroke(Math.max(thick, MINIMUM_THICKNESS),
-                                        CAP, JOIN, 10f, dash, 0.0f);
+                        _lineStroke = new Stroke(Math.max(thick, MINIMUM_THICKNESS), DEFAULT_CAP, DEFAULT_JOIN, dash, 0.0f);
                 } else
-                        _lineStroke = new BasicStroke(Math.max(thick, MINIMUM_THICKNESS),
-                                        CAP, JOIN);
+                        _lineStroke = new Stroke(Math.max(thick, MINIMUM_THICKNESS), DEFAULT_CAP, DEFAULT_JOIN);
 
                 if (_start.getLinePattern() != pattern)
@@ -333 +324 @@
 
         @Override
-        public void paint(Graphics2D g) {
-                if (!isVisible())
-                        return;
-
-                // Dont paint lines with thickness 0 if they are the border on a filled
-                // shape
-                if (dontPaint())
-                        return;
-
-                g.setColor(getPaintColor());
+        public void paint()
+        {
+                if (!isVisible()) return;
+
+                // Dont paint lines with thickness 0 if they are the border on a filled shape
+                if (dontPaint()) return;
 
                 // if (this._mode == Item.SelectedMode.Disconnect)
                 // System.out.println("Disconnect mode!");
-                g.setStroke(_lineStroke);
                 // Get a path of points
-                int[][][] paths = getPaths();
-                for (int i = 0; i < paths.length; i++) {
-                        int[][] path = paths[i];
-                        int last = path[0].length - 1;
-                        if (path[0][0] == path[0][last] && path[1][0] == path[1][last]) {
-                                g.drawPolygon(path[0], path[1], last);
-                        } else {
-                                g.drawPolyline(path[0], path[1], last + 1);
-                        }
-                }
+                PolygonBounds[] paths = getPaths();
+                for (PolygonBounds path : paths) {
+                        EcosystemManager.getGraphicsManager().drawPolygon(path, null, null, 0.0f, null, getPaintColor(), _lineStroke);
+                }
+                
                 // paint the arrowhead (if necessary)
-                paintArrows(g);
-
-                if (showLineHighlight() && isHighlighted()) {
-                        g.setColor(getHighlightColor());
-                        g.setStroke(HIGHLIGHT_STROKE);
-                        ((Graphics2D) g).draw(this.getArea());
+                paintArrows();
+
+                if (shouldShowLineHighlight() && isHighlighted()) {
+                        PolygonBounds poly = (PolygonBounds) getBounds();
+                        EcosystemManager.getGraphicsManager().drawPolygon(poly, null, null, 0.0f, null, getHighlightColor(), HIGHLIGHT_STROKE);
                 }
         }
@@ -371 +351 @@
                 // enable invisible shapes (for web browser divs) only when XRayMode is off
                 return getThickness() <= 0 && _start.isEnclosed()
-                                && (_start.getFillColor() != null || !FrameGraphics.isXRayMode());
-        }
-
-        protected int[][][] getPaths() {
+                                && (_start.getFillColor() != null || !DisplayController.isXRayMode());
+        }
+
+        protected PolygonBounds[] getPaths() {
                 List<List<Point>> pointPaths = new LinkedList<List<Point>>();
                 Collection<Line> visited = new HashSet<Line>();
@@ -388 +368 @@
                 }
                 // Put the paths into int arrays
-                int[][][] paths = new int[pointPaths.size()][][];
+                PolygonBounds[] paths = new PolygonBounds[pointPaths.size()];
                 Iterator<List<Point>> iter = pointPaths.iterator();
 
                 for (int i = 0; i < paths.length; i++) {
                         List<Point> pointPath = iter.next();
-                        int[][] path = new int[2][pointPath.size()];
+                        PolygonBounds path = new PolygonBounds();
                         paths[i] = path;
                         // Add all the x and y's to the array
-                        for (int j = 0; j < path[0].length; j++) {
-                                path[0][j] = pointPath.get(j).x;
-                                path[1][j] = pointPath.get(j).y;
-                        }
-                }
+                        for (int j = 0; j < pointPath.size(); j++) {
+                                path.addPoint(pointPath.get(j).x, pointPath.get(j).y);
+                        }
+                }
+                
                 return paths;
         }
 
-        protected List<Point> getPath(Collection<Line> visited,
-                        LinkedList<Line> toExplore) {
+        protected List<Point> getPath(Collection<Line> visited, LinkedList<Line> toExplore)
+        {
                 LinkedList<Point> points = new LinkedList<Point>();
                 // put the start item points into our list
@@ -417 +397 @@
         }
 
-        public void paintArrows(Graphics2D g) {
-                if (dontPaint())
-                        return;
-
-                g.setColor(getPaintColor());
-                g.setStroke(new BasicStroke(getPaintThickness(), CAP,
-                                BasicStroke.JOIN_MITER));
-                paintArrow(g, getStartArrow());
-                paintArrow(g, getEndArrow());
-
+        public void paintArrows()
+        {
+                if (dontPaint()) return;
+
+                paintArrow(getStartArrow());
+                paintArrow(getEndArrow());
+
+                // TODO: What is a virtual spot? cts16
                 if (_virtualSpot != null) {
-                        _virtualSpot.paint(g);
+                        _virtualSpot.paint();
                         invalidateVirtualSpot();
                         _virtualSpot = null;
@@ -456 +434 @@
          * @return
          */
-        private Shape getArrow(Item withArrow, Point startOffset, Point endOffset) {
-                boolean disconnectMode = withArrow._mode == Item.HighlightMode.Disconnect;
+        private PolygonBounds getArrow(Item withArrow, Point startOffset, Point endOffset)
+        {
+                boolean disconnectMode = withArrow._highlightMode == Item.HighlightMode.Disconnect;
+                
                 // only draw an arrowhead if necessary
-                if (!(this._mode == Item.HighlightMode.Disconnect && disconnectMode)
-                                && (!withArrow.hasVisibleArrow() || withArrow.getLines().size() > 1))
+                if (    !(this._highlightMode == Item.HighlightMode.Disconnect && disconnectMode) &&
+                                (!withArrow.hasVisibleArrow() || withArrow.getLines().size() > 1))
+                {
                         return null;
-
+                }
+                
                 int x0, x1, y0, y1;
 
@@ -475 +457 @@
                 
                 // set the size of the disconnect indicator arrowhead
-                if (this._mode == Item.HighlightMode.Disconnect) {
+                if (this._highlightMode == Item.HighlightMode.Disconnect) {
                         arrowLength  = 15;
                         arrowRatio   = 0.3;
@@ -494 +476 @@
                 // The length of the line must at least be as long as the arrow or we
                 // wont show the arrow
-                if (length <= MINIMUM_ARROW_HEAD_LENGTH)
-                        return null;
+                if (length <= MINIMUM_ARROW_HEAD_LENGTH) return null;
+                
                 if (arrowLength == AUTO_ARROWHEAD_LENGTH) {
                         arrowLength = getAutoArrowheadLength(length);
@@ -508 +490 @@
 
                 // only calculate the arrowhead polygon if necessary
-                Polygon arrowhead = withArrow.getArrowhead();
+                PolygonBounds arrowhead = withArrow.getArrowhead();
                 if (arrowhead == null || disconnectMode) {
-                        arrowhead = createArrowheadPolygon(x0,y0,arrowLength,arrowRatio,arrowNibPerc); 
+                        arrowhead = createArrowheadPolygon(x0, y0, arrowLength, arrowRatio, arrowNibPerc); 
                         
                         if (!disconnectMode)
-                                withArrow.setArrowhead(arrowhead);
-                }
+                                withArrow.setArrowhead(new PolygonBounds(arrowhead));
+                }
+                arrowhead = arrowhead.clone();
                 double rad = calcAngle((float) x0, (float) y0, (float) x1, (float) y1);
-                arrowhead.translate((x0 + length) - arrowhead.xpoints[0], y0
-                                - arrowhead.ypoints[0]);
-                AffineTransform tx = AffineTransform.getRotateInstance(rad, x0, y0);
-                
-        int[] rx = new int[arrowhead.npoints];
-        int[] ry = new int[arrowhead.npoints];
-        
-        for(int i = 0; i < arrowhead.npoints; i++){
-            Point2D p = new Point2D.Double(arrowhead.xpoints[i], arrowhead.ypoints[i]);
-            tx.transform(p,p);
-            rx[i] = (int) p.getX();
-            ry[i] = (int) p.getY();
-        }
-        
-        return new Polygon(rx, ry, arrowhead.npoints);
+                arrowhead.translate((x0 + length) - arrowhead.toArray()[0].x, y0 - arrowhead.toArray()[0].y);
+                arrowhead.rotate(rad, x0, y0);
+                
+                return arrowhead;
         }
         
-        public Polygon getStartArrow() {
-                return (Polygon) getArrow(_start, _startOffset, _endOffset);
+        public PolygonBounds getStartArrow() {
+                return getArrow(_start, _startOffset, _endOffset);
         }
         
-        public Polygon getEndArrow() {
-                return (Polygon) getArrow(_end, _endOffset, _startOffset);
+        public PolygonBounds getEndArrow() {
+                return getArrow(_end, _endOffset, _startOffset);
         }
 
@@ -544 +516 @@
          * Based on code from DeSL (Arrow2D) http://sourceforge.net/projects/desl/
          */
-        private void paintArrow(Graphics2D g, Shape arrow) {
+        private void paintArrow(PolygonBounds arrow)
+        {
+                Colour arrowColour = getPaintColor();
+                Fill arrowFill = new Fill(arrowColour);
+                Stroke arrowStroke = new Stroke(getPaintThickness(), DEFAULT_CAP, Stroke.JOIN.MITER);
                 
                 if(arrow == null) {
@@ -557 +533 @@
                 // ****
                 
-                g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
-                
-                g.draw(arrow);
-                g.fill(arrow);
+                GraphicsManager g = EcosystemManager.getGraphicsManager();
+                
+                g.setAntialiasing(true);
+                g.drawPolygon(arrow.close(), null, null, 0.0f, arrowFill, arrowColour, arrowStroke);
         
         }
@@ -630 +606 @@
                 return temp;
         }
+        
+        public Item getEndPointToDisconnect(Point p)
+        {
+                return getEndPointToDisconnect(p.x, p.y);
+        }
 
         public Item getEndPointToDisconnect(int x, int y) {
@@ -653 +634 @@
 
                 if (distStart < NORMAL_THRESHHOLD) {
-                        start._mode = Item.HighlightMode.Normal;
+                        start._highlightMode = Item.HighlightMode.Normal;
                         return start;
                 } else if (distEnd < NORMAL_THRESHHOLD) {
-                        end._mode = Item.HighlightMode.Normal;
+                        end._highlightMode = Item.HighlightMode.Normal;
                         return end;
                 } else if (distStart < DISCONNECT_THRESHHOLD) {
                         if (start.getLines().size() > 1
                                         || start.getConstraints().size() > 0)
-                                start._mode = Item.HighlightMode.Disconnect;
+                                start._highlightMode = Item.HighlightMode.Disconnect;
                         else
-                                start._mode = Item.HighlightMode.Normal;
+                                start._highlightMode = Item.HighlightMode.Normal;
                         return start;
                 } else if (distEnd < DISCONNECT_THRESHHOLD) {
                         if (end.getLines().size() > 1 || end.getConstraints().size() > 0)
-                                end._mode = Item.HighlightMode.Disconnect;
+                                end._highlightMode = Item.HighlightMode.Disconnect;
                         else
-                                end._mode = Item.HighlightMode.Normal;
+                                end._highlightMode = Item.HighlightMode.Normal;
                         return end;
                 }
@@ -677 +658 @@
 
         @Override
-        public int setHighlightColor() {
-                super.setHighlightColor();
-
-                return Item.UNCHANGED_CURSOR;
+        public void setHighlightColorToDefault() {
+                super.setHighlightColorToDefault();
+
+                //return Item.UNCHANGED_CURSOR;
         }
 
@@ -690 +671 @@
          */
         @Override
-        public void setColor(Color c) {
+        public void setColor(Colour c) {
                 super.setColor(c);
 
@@ -698 +679 @@
 
         @Override
-        public Color getFillColor() {
+        public Colour getFillColor() {
                 return _start.getFillColor();
         }
@@ -882 +863 @@
         private Item _virtualSpot = null;
 
-        public void showVirtualSpot(Item orig, int mouseX, int mouseY) {
-                if (orig.getLines().size() != 1)
-                        return;
+        public void showVirtualSpot(Item orig, int mouseX, int mouseY)
+        {
+                if (orig.getLines().size() != 1) return;
 
                 // lines that are in 'connected' mode, also cannot be attached
-                if (orig.getLines().get(0).getOppositeEnd(orig).isFloating())
-                        return;
+                if (orig.getLines().get(0).getOppositeEnd(orig).isFloating()) return;
 
                 Item spot = new Dot(-1, orig.getX(), orig.getY());
                 Item.DuplicateItem(orig, spot);
                 spot.setThickness(Math.max(this.getThickness(), 5));
-                if (this.getColor() != Color.RED)
-                        spot.setColor(Color.RED);
-                else
-                        spot.setColor(Color.BLUE);
-
+                if (!this.getColor().equals(Colour.RED)) {
+                        spot.setColor(Colour.RED);
+                } else {
+                        spot.setColor(Colour.BLUE);
+                }
+                
                 // unhighlight all the dots
                 for (Item conn : getAllConnected()) {
                         conn.setHighlightMode(Item.HighlightMode.None);
-                }
+                        conn.setHighlightColorToDefault();
+                }
+
+                // calculate nearest point on line from spot
+                org.expeditee.core.Line line = new org.expeditee.core.Line(_start.getPosition(), _end.getPosition());
+                Point nearest = line.getPointNearestTo(spot.getPosition());
+
+                // position spot on the line
+                spot.setPosition(nearest);
+                _virtualSpot = spot;
+                invalidateVirtualSpot();
+        }
+
+        public void showVirtualSpot(int mouseX, int mouseY) {
+                Item spot = new Dot(mouseX, mouseY, -1);
+                spot.setThickness(Math.max(this.getThickness(), 5));
+                if (DEFAULT_HIGHLIGHT.equals(this.getColor()))
+                        spot.setColor(ALTERNATE_HIGHLIGHT);
+                else
+                        spot.setColor(DEFAULT_HIGHLIGHT);
+
+
+                // calculate nearest point on line from spot
+                org.expeditee.core.Line line = new org.expeditee.core.Line(_start.getPosition(), _end.getPosition());
+                Point nearest = line.getPointNearestTo(spot.getPosition());
+
+                // position spot on the line
+                spot.setPosition(nearest);
+                _virtualSpot = spot;
+                invalidateVirtualSpot();
+        }
+
+        public Item forceMerge(Item spot, int mouseX, int mouseY) {
 
                 // calculate nearest point on line from spot
@@ -930 +943 @@
                 // position spot on the line
                 spot.setPosition((int) x, (int) y);
-                _virtualSpot = spot;
-                invalidateVirtualSpot();
-        }
-
-        public void showVirtualSpot(int mouseX, int mouseY) {
-                Item spot = new Dot(mouseX, mouseY, -1);
-                spot.setThickness(Math.max(this.getThickness(), 5));
-                if (DEFAULT_HIGHLIGHT.equals(this.getColor()))
-                        spot.setColor(ALTERNATE_HIGHLIGHT);
-                else
-                        spot.setColor(DEFAULT_HIGHLIGHT);
-
-                // calculate nearest point on line from spot
-                double slope1;
-                double slope2;
-                double x, y;
-
-                slope1 = (_start.getY() - _end.getY() * 1.0)
-                                / (_start.getX() - _end.getX());
-                slope2 = -1 / slope1;
-
-                // if the line is horizontal
-                if (slope1 == 0) {
-                        x = spot.getX();
-                        y = _start.getY();
-                        // if the line is vertical
-                } else if (slope2 == 0) {
-                        x = _start.getX();
-                        y = spot.getY();
-                        // otherwise, the line is sloped
-                } else {
-                        x = (-1 * slope2 * spot.getX() + spot.getY() - _start.getY() + slope1
-                                        * _start.getX())
-                                        / (slope1 - slope2);
-                        y = slope1 * (x - _start.getX()) + _start.getY();
-                }
-
-                // position spot on the line
-                spot.setPosition((int) x, (int) y);
-                _virtualSpot = spot;
-                invalidateVirtualSpot();
-        }
-
-        public Item forceMerge(Item spot, int mouseX, int mouseY) {
-
-                // calculate nearest point on line from spot
-                double slope1;
-                double slope2;
-                double x, y;
-
-                slope1 = (_start.getY() - _end.getY() * 1.0)
-                                / (_start.getX() - _end.getX());
-                slope2 = -1 / slope1;
-
-                // if the line is horizontal
-                if (slope1 == 0) {
-                        x = spot.getX();
-                        y = _start.getY();
-                        // if the line is vertical
-                } else if (slope2 == 0) {
-                        x = _start.getX();
-                        y = spot.getY();
-                        // otherwise, the line is sloped
-                } else {
-                        x = (-1 * slope2 * spot.getX() + spot.getY() - _start.getY() + slope1
-                                        * _start.getX())
-                                        / (slope1 - slope2);
-                        y = slope1 * (x - _start.getX()) + _start.getY();
-                }
-
-                // position spot on the line
-                spot.setPosition((int) x, (int) y);
 
                 // Keep constraints
@@ -1018 +959 @@
                 Line temp = copy();
 
-                Frame currentFrame = DisplayIO.getCurrentFrame();
+                Frame currentFrame = DisplayController.getCurrentFrame();
                 temp.setID(currentFrame.getNextItemID());
                 temp.setEndItem(_end);
@@ -1101 +1042 @@
 
         @Override
-        public void updatePolygon() {
-                _poly = new Polygon();
-
-                Rectangle one;
-                Rectangle two;
+        public PolygonBounds updateBounds() {
+                PolygonBounds ret = new PolygonBounds();
+
+                AxisAlignedBoxBounds one;
+                AxisAlignedBoxBounds two;
 
                 /**
@@ -1121 +1062 @@
                         Item e = new Dot(_end.getX(), _end.getY(), -1);
 
-                        one = s.getPolygon().getBounds();
-                        two = e.getPolygon().getBounds();
+                        one = AxisAlignedBoxBounds.getEnclosing(s.getBounds());
+                        two = AxisAlignedBoxBounds.getEnclosing(e.getBounds());
                 } else {
                         Item s = new Dot(_start.getX(), _start.getY(), -1);
                         Item e = new Dot(_end.getX(), _end.getY(), -1);
 
-                        one = e.getPolygon().getBounds();
-                        two = s.getPolygon().getBounds();
+                        one = AxisAlignedBoxBounds.getEnclosing(e.getBounds());
+                        two = AxisAlignedBoxBounds.getEnclosing(s.getBounds());
                         /*
                          * one = _end.getPolygon().getBounds(); two =
@@ -1136 +1077 @@
 
                 // if one is above two
-                if (one.getY() < two.getY()) {
-                        _poly.addPoint((int) one.getMaxX(), (int) one.getMinY());
-                        _poly.addPoint((int) two.getMaxX(), (int) two.getMinY());
-                        _poly.addPoint((int) two.getMinX(), (int) two.getMaxY());
-                        _poly.addPoint((int) one.getMinX(), (int) one.getMaxY());
+                if (one.getMinY() < two.getMinY()) {
+                        ret.addPoint(one.getMaxX(), one.getMinY());
+                        ret.addPoint(two.getMaxX(), two.getMinY());
+                        ret.addPoint(two.getMinX(), two.getMaxY());
+                        ret.addPoint(one.getMinX(), one.getMaxY());
                         // if one is below two
                 } else {
-                        _poly.addPoint((int) one.getMinX(), (int) one.getMinY());
-                        _poly.addPoint((int) two.getMinX(), (int) two.getMinY());
-                        _poly.addPoint((int) two.getMaxX(), (int) two.getMaxY());
-                        _poly.addPoint((int) one.getMaxX(), (int) one.getMaxY());
-                }
-
+                        ret.addPoint(one.getMinX(), one.getMinY());
+                        ret.addPoint(two.getMinX(), two.getMinY());
+                        ret.addPoint(two.getMaxX(), two.getMaxY());
+                        ret.addPoint(one.getMaxX(), one.getMaxY());
+                }
+                
+                return ret.close();
         }
 
@@ -1199 +1141 @@
 
         public double getLength() {
-                return getLength(_start.getPosition(), _end.getPosition());
+                return Point.distanceBetween(_start.getPosition(), _end.getPosition());
         }
 
@@ -1210 +1152 @@
         }
 
-        public static double getLength(Point p1, Point p2) {
-                return Point.distance(p1.x, p1.y, p2.x, p2.y);
-        }
-
-        @Override
-        public Rectangle[] getDrawingArea() { // TODO: CACHE - LIKE UPDATE POLYGON
+/*      public static double getLength(Point p1, Point p2) {
+                return Point.distance(p1, p2);
+        }*/
+
+        @Override
+        public AxisAlignedBoxBounds getDrawingArea() { // TODO: CACHE - LIKE UPDATE POLYGON
 
                 float currentThickness = this.getThickness() + 4;
@@ -1236 +1178 @@
                 y -= halfThickness;
 
-                Rectangle bounds = new Rectangle(x, y, w, h);
+                AxisAlignedBoxBounds bounds = new AxisAlignedBoxBounds(x, y, w, h);
 
                 // TODO: Cap bounds
@@ -1257 +1199 @@
                          overall as opposed to advanced/expensive calculations for getting exact
                          bounding box */
-                        Rectangle arrowBounds = new Rectangle(_end.getX() - nArrowLength,
+                        AxisAlignedBoxBounds arrowBounds = new AxisAlignedBoxBounds(_end.getX() - nArrowLength,
                                         _end.getY() - nArrowLength, 2 * nArrowLength,
                                         2 * nArrowLength);
@@ -1263 +1205 @@
                         if (currentThickness > 0.0f) {
 
-                                arrowBounds = new Rectangle(arrowBounds.x - halfThickness,
-                                                arrowBounds.y - halfThickness, arrowBounds.width
-                                                                + thickness, arrowBounds.height + thickness);
-                        }
-
-                        return new Rectangle[] { bounds, arrowBounds };
+                                arrowBounds = new AxisAlignedBoxBounds(arrowBounds.getMinX() - halfThickness,
+                                                arrowBounds.getMinY() - halfThickness, arrowBounds.getWidth()
+                                                                + thickness, arrowBounds.getHeight() + thickness);
+                        }
+
+                        return bounds.combineWith(arrowBounds);
                 } else {
-                        return new Rectangle[] { bounds };
+                        return bounds;
                 }
 
@@ -1294 +1236 @@
         public void scale(Float scale, int originX, int originY) {
         }
+
+        @Override
+        public float getSize()
+        {
+                return getThickness();
+        }
 }