source: trunk/src/org/expeditee/items/Dot.java@ 1415

/**
 *    Dot.java
 *    Copyright (C) 2010 New Zealand Digital Library, http://expeditee.org
 *
 *    This program is free software: you can redistribute it and/or modify
 *    it under the terms of the GNU General Public License as published by
 *    the Free Software Foundation, either version 3 of the License, or
 *    (at your option) any later version.
 *
 *    This program is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *    GNU General Public License for more details.
 *
 *    You should have received a copy of the GNU General Public License
 *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

package org.expeditee.items;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

import org.expeditee.core.Colour;
import org.expeditee.core.Dimension;
import org.expeditee.core.Fill;
import org.expeditee.core.Point;
import org.expeditee.core.bounds.AxisAlignedBoxBounds;
import org.expeditee.core.bounds.Bounds;
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;

/**
 * Represents a point on the screen. All Point objects are stored as x,y pairs
 * with an Item ID. Note: Lines and all combinates of lines (rectangles, etc)
 * are represented only as Points that share line IDs.
 * 
 * @author jdm18
 * 
 */
public class Dot extends Item {

        // Standard Item variables

        // private static final int _MINIMUM_DOT_SIZE = 6;

        private static final int MINIMUM_DOT_SIZE = 2;

        public Dot(int id) {
                super();
                setID(id);
        }

        /**
         * Constructs a new Point with the given x,y coordinates and Item ID.
         * 
         * @param x
         *            The x coordinate of this point
         * @param y
         *            The y coordinate of this point
         * @param id
         *            The Item ID of this Point
         */
        public Dot(int x, int y, int id) {
                super();
                setID(id);
                setPosition(x, y);
        }

        @Override
        public void setColor(Colour c) {
                super.setColor(c);

                // update the colour of any lines
                for (Line line : getLines())
                        line.setColor(c);
        }

        @Override
        public void setAnchorLeft(Integer anchor) {
                if (!isLineEnd()) {
                        super.setAnchorLeft(anchor);
                        return;
                }
                
                invalidateFill();
                invalidateCommonTrait(ItemAppearence.PreMoved);
                
                this._anchoring.setLeftAnchor(anchor);
                
                int oldX = getX();
                if (anchor != null) {
                        float deltaX = anchor - oldX;
                        anchorConnected(AnchorEdgeType.Left, deltaX);
                }
                
                invalidateCommonTrait(ItemAppearence.PostMoved);
                invalidateFill();
        }

        @Override
        public void setAnchorRight(Integer anchor) {
                if (!isLineEnd()) {
                        super.setAnchorRight(anchor);
                        return;
                }
                invalidateFill();
                invalidateCommonTrait(ItemAppearence.PreMoved);
                
                this._anchoring.setRightAnchor(anchor);
                
                int oldX = getX();
                if (anchor != null) {
                        float deltaX = DisplayController.getFramePaintAreaWidth() - anchor - getBoundsWidth() - oldX;

                        anchorConnected(AnchorEdgeType.Right, deltaX);
                }
        
                invalidateCommonTrait(ItemAppearence.PostMoved);
                invalidateFill();
        }

        @Override
        public void setAnchorTop(Integer anchor) {
                if (!isLineEnd()) {
                        super.setAnchorTop(anchor);
                        return;
                }
                invalidateFill();
                invalidateCommonTrait(ItemAppearence.PreMoved);
                
                this._anchoring.setTopAnchor(anchor);
                
                int oldY = getY();
                if (anchor != null) {
                        float deltaY = anchor - oldY;
                        anchorConnected(AnchorEdgeType.Top, deltaY);
                }

                invalidateCommonTrait(ItemAppearence.PostMoved);
                invalidateFill();
        }

        @Override
        public void setAnchorBottom(Integer anchor) {
                if (!isLineEnd()) {
                        super.setAnchorBottom(anchor);
                        return;
                }
                invalidateFill();
                invalidateCommonTrait(ItemAppearence.PreMoved);
                
                this._anchoring.setBottomAnchor(anchor);
                
                int oldY = getY();
                if (anchor != null) {
                        float deltaY = DisplayController.getFramePaintAreaHeight() - anchor - getBoundsHeight() - oldY;
                        anchorConnected(AnchorEdgeType.Bottom, deltaY);
                }

                invalidateCommonTrait(ItemAppearence.PostMoved);
                invalidateFill();
        }



        @Override
        public void paint() {
                GraphicsManager g = EcosystemManager.getGraphicsManager();
                if (isHighlighted() /* && !FreeItems.getInstance().contains(this) */) {
                        Colour highlightColor = getHighlightColor();
                        Fill fill = new Fill(highlightColor);
                        // g.setStroke()
                        // Draw the highlighting rectangle surrounding the dot
                        // this is drawn even if its part of a rectangle

                        if (isVectorItem()) invalidateBounds();

                        AxisAlignedBoxBounds bounds = getBoundingBox();
                        if (_highlightMode == HighlightMode.Enclosed || this.getConnected().size() <= 1) { // Make sure single dots are highlighted filled
                                g.drawRectangle(bounds.getTopLeft(), bounds.getSize(), 0.0f, fill, highlightColor, DOT_STROKE, null);
                        } else if (_highlightMode == HighlightMode.Connected) {
                                g.drawRectangle(bounds.getTopLeft(), bounds.getSize(), 0.0f, null, highlightColor, HIGHLIGHT_STROKE, null);
                        } else if (_highlightMode == HighlightMode.Normal) {
                                g.drawOval(bounds.getCentre(), bounds.getSize(), 0.0f, fill, highlightColor, DOT_STROKE);
                        }
                        // System.out.println(_mode.toString());
                }

                // dots on lines are hidden
                if (getLines().size() > 0) return;

                int thick = (int) getThickness();
                if (thick < MINIMUM_DOT_SIZE) thick = MINIMUM_DOT_SIZE;
                
                Fill fill = _filled ? new Fill(getPaintColor()) : null;

                // TODO: On testing, this code doesn't seem to work (can't change to any type except square). cts16
                switch (_type) {
                        case circle:
                                g.drawOval(
                                                new Point(getX(), getY()),
                                                new Dimension(thick, thick),
                                                0.0,
                                                fill,
                                                getPaintColor(),
                                                null
                                );
                                break;
                        case diamond:
                                PolygonBounds diamond = PolygonBounds.getDiamond(thick, thick).translate(getX(), getY()).close();
                                g.drawPolygon(diamond, null, null, 0.0, fill, getPaintColor(), null);
                                break;
                        case triangle:
                                PolygonBounds triangle = PolygonBounds.getTriangle(thick, thick).translate(getX(), getY()).close();
                                g.drawPolygon(triangle, null, null, 0.0, fill, getPaintColor(), null);
                                break;
                        case roundSquare:
                                int arc = thick / 4;
                                g.drawRectangle(
                                        new Point(getX(), getY()),
                                        new Dimension(thick, thick),
                                        0.0,
                                        fill,
                                        getPaintColor(),
                                        null,
                                        new Dimension(arc, arc)
                                );
                                break;
                        default:
                                g.drawRectangle(
                                                new Point(getX(), getY()),
                                                new Dimension(thick, thick),
                                                0.0,
                                                fill,
                                                getPaintColor(),
                                                null,
                                                null
                                );
                }

        }

        /**
         * Updates the bounds surrounding this Dot.
         * TODO: Standardise Dot minimum size. cts16
         */
        public Bounds updateBounds()
        {
                int thick = Math.round(getThickness());
                
                // Sets a minimum size for the dot
                thick = Math.max(thick, getGravity() * 2);
                
                // Include the gravity in the thickness
                thick += 2 * getGravity();
                

                int x = getX() - thick / 2;
                int y = getY() - thick / 2;
                
                return new AxisAlignedBoxBounds(x, y, thick, thick);
        }

        @Override
        public Item copy() {
                Dot copy = new Dot(getX(), getY(), getID());

                Item.DuplicateItem(this, copy);

                return copy;
        }

        @Override
        public void setHighlightColorToDefault() {
                super.setHighlightColorToDefault();

                //return Item.DEFAULT_CURSOR;
        }

        @Override
        public void setAnnotation(boolean val) {
                DisplayController.setCursorPosition(this.getPosition());
                Item.replaceDot(this, '@');
        }

        @Override
        public Item merge(Item merger, int mouseX, int mouseY) {
                // if the item being merged with is another Dot
                if (merger instanceof Dot) {
                        if (merger.hasEnclosures() || hasEnclosures())
                                return merger;

                        Item dot = (Item) merger;
                        merger.setPosition(this.getPosition());
                        // prevent concurrency issues if removing lines
                        List<Line> lines = new ArrayList<Line>();
                        lines.addAll(dot.getLines());

                        for (Line line : lines) {
                                // remove lines that are in common
                                if (getLines().contains(line)) {
                                        dot.removeLine(line);
                                        removeLine(line);
                                } else {
                                        // check for duplicated lines as a result of merging
                                        Item check = (Item) line.getOppositeEnd(dot);
                                        boolean dup = false;

                                        for (Line l : getLines()) {
                                                Item opposite = l.getOppositeEnd(this);

                                                if (check == opposite) {
                                                        line.getStartItem().removeLine(line);
                                                        line.getEndItem().removeLine(line);
                                                        dup = true;
                                                        break;
                                                }
                                        }

                                        if (!dup)
                                                line.replaceLineEnd(dot, this);
                                }
                        }

                        setThickness(dot.getThickness());
                        setColor(dot.getColor());
                        setFillColor(dot.getFillColor());

                        return null;
                }

                if (merger instanceof Text) {
                        merger.setPosition(this.getPosition());
                        List<Line> lines = new LinkedList<Line>();
                        lines.addAll(getLines());
                        for (Line line : lines)
                                line.replaceLineEnd(this, merger);
                        this.delete();
                        return merger;
                }

                // if the item being merged with is a Line
                if (merger instanceof Line) {
                        Line line = (Line) merger;
                        // if this dot is part of the line then keep it, otherwise it
                        // can be removed
                        if (line.getOppositeEnd(this) != null && getLines().contains(line))
                                return merger;
                        else
                                return null;
                }

                return merger;
        }

        @Override
        public String getTypeAndID() {
                return "P " + getID();
        }

        @Override
        public void delete() {
                super.delete();

                for (Line l : this.getLines())
                        l.delete();
        }

        @Override
        public void anchor() {
                Frame current = getParentOrCurrentFrame();
                // This is to make lines anchored across frames be on one frame
                for (Line l : getLines()) {
                        Frame parent = l.getOppositeEnd(this).getParent();
                        if (parent != null && parent != current) {
                                this.setParent(parent);
                                if (DisplayController.getCurrentSide() == DisplayController.TwinFramesSide.LEFT)
                                        this.setX(this.getX() - DisplayController.getTwinFramesSeparatorX());
                                else
                                        this.setX(this.getX() + DisplayController.getTwinFramesSeparatorX());
                        }
                        break;
                }

                super.anchor();

                // TODO is the code below needed... what for?
                for (Line line : getLines()) {
                        if (line.getID() < 0 && !current.getSortedItems().contains(line)) {
                                line.setID(current.getNextItemID());
                                line.setHighlightColorToDefault();
                                // Mike: Why was this line here?
                                // anchor(line);
                        }
                }
        }

        @Override
        public void addLine(Line line) {
                super.addLine(line);
                line.setColor(getColor());
                line.setThickness(getThickness());
                line.setLinePattern(getLinePattern());
        }

        @Override
        public void lineColorChanged(Colour c) {
                if (getColor() != c) {
                        setColor(c);
                }
        }

        @Override
        public boolean dontSave() {
                if (getThickness() <= 1 && (getLines().size() == 0)
                                && getConstraints().size() == 0) {
                        return true;
                }
                return super.dontSave();
        }

        @Override
        public float getSize()
        {
                return getThickness();
        }
}