source: trunk/src/org/expeditee/gui/FrameGraphics.java@ 1415

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

import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;

import org.expeditee.core.Clip;
import org.expeditee.core.Colour;
import org.expeditee.core.Dimension;
import org.expeditee.core.Image;
import org.expeditee.core.bounds.PolygonBounds;
import org.expeditee.gio.EcosystemManager;
import org.expeditee.gio.input.KBMInputEvent.Key;
import org.expeditee.gio.input.StandardInputEventListeners;
import org.expeditee.items.Circle;
import org.expeditee.items.Dot;
import org.expeditee.items.Item;
import org.expeditee.items.Item.HighlightMode;
import org.expeditee.items.Line;
import org.expeditee.items.UserAppliedPermission;
import org.expeditee.items.XRayable;
import org.expeditee.items.widgets.Widget;
import org.expeditee.items.widgets.WidgetEdge;
import org.expeditee.settings.UserSettings;

public class FrameGraphics {

        // Final passes to rendering the current frame
        private static LinkedList<FrameRenderPass> _frameRenderPasses = new LinkedList<FrameRenderPass>();
        
        private static Item _lastToolTippedItem = null;

        /** Static-only class. */
        private FrameGraphics()
        {
        }

        /**
         * Gets an image of the given frame that has the given dimensions. If clip
         * is not null, only the areas inside clip are guaranteed to be drawn.
         */
        public static Image getFrameImage(Frame toPaint, Clip clip, Dimension size)
        {
                return getFrameImage(toPaint, clip, size, true, true);
        }

        /**
         * Gets an image of the given frame that has the given dimensions. If clip
         * is not null, only the areas inside clip are guaranteed to be drawn.
         */
        public static Image getFrameImage(Frame toPaint, Clip clip, Dimension size, boolean isActualFrame, boolean createVolatile)
        {
                if (toPaint == null) {
                        return null;
                }

                // the buffer is not valid, so it must be recreated
                if (!toPaint.isBufferValid()) {
                        
                        Image buffer = toPaint.getBuffer();
                        // Get the size if it hasn't been given
                        if (size == null) {
                                // Can't get the size if there is no buffer
                                if (buffer == null) {
                                        return null;
                                } else {
                                        size = buffer.getSize();
                                }
                        }
                        
                        if (buffer == null || !buffer.getSize().equals(size)) {
                                buffer = Image.createImage(size.width, size.height, createVolatile);
                                toPaint.setBuffer(buffer);
                                clip = null;
                        }
                        
                        EcosystemManager.getGraphicsManager().pushDrawingSurface(buffer);
                        EcosystemManager.getGraphicsManager().pushClip(clip);
                        paintFrame(toPaint, isActualFrame, createVolatile);
                        EcosystemManager.getGraphicsManager().popDrawingSurface();
                }

                return toPaint.getBuffer();
        }

        /** TODO: Comment. cts16 */
        public static void paintFrame(Frame toPaint, boolean isActualFrame, boolean createVolitile)
        {
                Clip clip = EcosystemManager.getGraphicsManager().peekClip();
                
                // Prepare render passes
                if (isActualFrame) {
                        for (FrameRenderPass pass : _frameRenderPasses) {
                                clip = pass.paintStarted(clip);
                        }
                }

                // TODO: Revise images and clip - VERY IMPORTANT

                // Nicer looking lines, but may be too jerky while
                // rubber-banding on older machines
                if (UserSettings.AntiAlias.get()) {
                        EcosystemManager.getGraphicsManager().setAntialiasing(true);
                }
                
                // If we are doing @f etc... then have a clear background if its the default background color
                Colour backgroundColor = null;
                
                // Need to allow transparency for frameImages
                if (createVolitile) {
                        backgroundColor = toPaint.getPaintBackgroundColor();
                } else {
                        backgroundColor = toPaint.getBackgroundColor();
                        if (backgroundColor == null) {
                                backgroundColor = Item.TRANSPARENT;
                        }
                }

                EcosystemManager.getGraphicsManager().clear(backgroundColor);

                List<Item> itemsToPaintCanditates = new LinkedList<Item>();
                List<Widget> paintWidgets;

                if (isActualFrame) {
                        // Add all the items for this frame and any other from other
                        // frames
                        itemsToPaintCanditates.addAll(toPaint.getAllItems());
                        paintWidgets = toPaint.getAllOverlayWidgets();
                        paintWidgets.addAll(toPaint.getInteractiveWidgets());
                } else {
                        itemsToPaintCanditates.addAll(toPaint.getVisibleItems());
                        itemsToPaintCanditates.addAll(toPaint.getVectorItems());
                        paintWidgets = toPaint.getInteractiveWidgets();
                }

                HashSet<Item> paintedFillsAndLines = new HashSet<Item>();
                // FIRST: Paint widgets swing gui (not expeditee gui) .
                // Note that these are the anchored widgets
                ListIterator<Widget> widgetItor = paintWidgets.listIterator(paintWidgets.size());
                while (widgetItor.hasPrevious()) {
                        // Paint first-in-last-serve ordering - like swing
                        // If it is done the other way around then widgets are covered up by
                        // the box that is supposed to be underneath
                        Widget iw = widgetItor.previous();
                        if (clip == null || clip.getBounds() == null || clip.getBounds().intersects(iw.getBounds())) {
                                paintedFillsAndLines.addAll(iw.getItems());
                                //iw.paint(bg);
                                //PaintItem(bg, iw.getItems().get(4));

                        }
                }

                
                // Filter out items that do not need to be painted
                List<Item> paintItems;
                HashSet<Item> fillOnlyItems = null; // only contains items that do
                // not need drawing but fills
                // might

                if (clip == null) {
                        paintItems = itemsToPaintCanditates;
                } else {
                        fillOnlyItems = new HashSet<Item>();
                        paintItems = new LinkedList<Item>();
                        for (Item i : itemsToPaintCanditates) {
                                if (clip == null || i.isInDrawingArea(clip.getBounds())) {
                                        paintItems.add(i);
                                } else if (i.isEnclosed()) {
                                        // just add all fill items despite possibility of fills
                                        // not being in clip
                                        // because it will be faster than having to test twice
                                        // for fills that do need
                                        // repainting.
                                        fillOnlyItems.add(i);
                                }
                        }
                }
                
                // Only paint files and lines once ... between anchored AND free items
                PaintPictures(paintItems, fillOnlyItems, paintedFillsAndLines);
                PaintLines(itemsToPaintCanditates);


                widgetItor = paintWidgets.listIterator(paintWidgets.size());
                while (widgetItor.hasPrevious()) {
                        // Paint first-in-last-serve ordering - like swing
                        // If it is done the other way around then widgets are covered up by
                        // the box that is supposed to be underneath
                        Widget iw = widgetItor.previous();
                        if (clip == null || clip.isNotClipped() || clip.getBounds().intersects(iw.getClip().getBounds())) {
                                iw.paint();
                                PaintItem(iw.getItems().get(4));
                        }
                }


                // Filter out free items that do not need to be painted
                // This is efficient in cases with animation while free items exist

                List<Item> freeItemsToPaint = new LinkedList<Item>();
                // Dont paint the free items for the other frame in twin frames mode
                // if (toPaint == DisplayIO.getCurrentFrame()) {
                if (clip == null || clip.isNotClipped()) {
                        freeItemsToPaint = FreeItems.getInstance();
                } else {
                        freeItemsToPaint = new LinkedList<Item>();
                        fillOnlyItems.clear();
                        for (Item i : FreeItems.getInstance()) {
                                if (i.isInDrawingArea(clip.getBounds())) {
                                        freeItemsToPaint.add(i);
                                } else if (i.isEnclosed()) {
                                        fillOnlyItems.add(i);
                                }
                        }
                }
                // }

                if (isActualFrame && toPaint == DisplayController.getCurrentFrame()) {
                        PaintPictures(freeItemsToPaint, fillOnlyItems, paintedFillsAndLines);
                }
                
                // TODO if we can get transparency with FreeItems.getInstance()...
                // then text can be done before freeItems
                PaintNonLinesNonPicture(paintItems);

                // toPaint.setBufferValid(true);

                if (isActualFrame && !DisplayController.isAudienceMode()) {
                        PaintItem(toPaint.getNameItem());
                }

                if (DisplayController.isTwinFramesOn()) {
                        List<Item> lines = new LinkedList<Item>();
                        for (Item i : freeItemsToPaint) {
                                if (i instanceof Line) {
                                        Line line = (Line) i;

                                        if (toPaint == DisplayController.getCurrentFrame()) {
                                                // If exactly one end of the line is floating...

                                                if (line.getEndItem().isFloating()
                                                                ^ line.getStartItem().isFloating()) {
                                                        // Line l = TransposeLine(line,
                                                        // line.getEndItem(),
                                                        // toPaint, 0, 0);
                                                        // if (l == null)
                                                        // l = TransposeLine(line,
                                                        // line.getStartItem(), toPaint, 0, 0);
                                                        // if (l == null)
                                                        // l = line;
                                                        // lines.add(l);
                                                } else {
                                                        // lines.add(line);
                                                }
                                        } else {
                                                // if (line.getEndItem().isFloating()
                                                // ^ line.getStartItem().isFloating()) {
                                                // lines.add(TransposeLine(line,
                                                // line.getEndItem(), toPaint,
                                                // FrameMouseActions.getY(), -DisplayIO
                                                // .getMiddle()));
                                                // lines.add(TransposeLine(line, line
                                                // .getStartItem(), toPaint,
                                                // FrameMouseActions.getY(), -DisplayIO
                                                // .getMiddle()));
                                                // }
                                        }
                                }
                        }
                        
                        if (isActualFrame) {
                                PaintLines(lines);
                        }
                } else {
                        if (isActualFrame) {
                                PaintLines(freeItemsToPaint);
                        }
                }

                if (isActualFrame && toPaint == DisplayController.getCurrentFrame()) {
                        PaintNonLinesNonPicture(freeItemsToPaint);
                }

                // Repaint popups / drags... As well as final passes
                if (isActualFrame) {
                        for (FrameRenderPass pass : _frameRenderPasses) {
                                pass.paintPreLayeredPanePass();
                        }
                        
                        //if (PopupManager.getInstance() != null) PopupManager.getInstance().paintLayeredPane(clip == null ? null : clip.getBounds());
                        
                        for (FrameRenderPass pass : _frameRenderPasses) {
                                pass.paintFinalPass();
                        }
                }
                
                // paint tooltip
                if(!FreeItems.hasItemsAttachedToCursor()) {
                        Item current = FrameUtils.getCurrentItem();
                        if(current != null) {
                                current.paintTooltip();
                        }
                        if (_lastToolTippedItem != null) {
                                _lastToolTippedItem.clearTooltips();
                        }
                        _lastToolTippedItem = current;
                }

                if (FreeItems.hasCursor() && DisplayController.getCursor() == Item.DEFAULT_CURSOR) {
                        PaintNonLinesNonPicture(FreeItems.getCursor());
                }
        }

        private static void PaintNonLinesNonPicture(List<Item> toPaint)
        {
                for (Item i : toPaint) {
                        if (!(i instanceof Line) && !(i instanceof XRayable)) {
                                PaintItem(i);
                        }
                }
        }

        /**
         * Paint the lines that are not part of an enclosure.
         * 
         * @param g
         * @param toPaint
         */
        private static void PaintLines(List<Item> toPaint)
        {
                // Use this set to keep track of the items that have been painted
                Collection<Item> done = new HashSet<Item>();
                for (Item i : toPaint) {
                        if (i instanceof Line) {
                                Line l = (Line) i;
                                if (done.contains(l)) {
                                        l.paintArrows();
                                } else {
                                        // When painting a line all connected lines are painted too
                                        done.addAll(l.getAllConnected());
                                        if (l.getStartItem().getEnclosedArea() == 0) {
                                                PaintItem(i);
                                        }
                                }
                        }
                }
        }

        /**
         * Paint filled areas and their surrounding lines as well as pictures. Note:
         * floating widgets are painted as fills
         * 
         * @param g
         * @param toPaint
         */
        private static void PaintPictures(List<Item> toPaint, HashSet<Item> fillOnlyItems, HashSet<Item> done)
        {

                List<Item> toFill = new LinkedList<Item>();
                
                for (Item i : toPaint) {
                        // Ignore items that have already been done!
                        // Also ignore invisible items..
                        // TODO possibly ignore invisible items before coming to this method?
                        if (done.contains(i)) {
                                continue;
                        }
                        
                        if (i instanceof XRayable) {
                                toFill.add(i);
                                done.addAll(i.getConnected());
                        } else if (i.hasEnclosures()) {
                                for (Item enclosure : i.getEnclosures()) {
                                        if (!toFill.contains(enclosure)) {
                                                toFill.add(enclosure);
                                        }
                                }
                                done.addAll(i.getConnected());
                        } else if (i.isLineEnd() && (!DisplayController.isAudienceMode() || !i.isConnectedToAnnotation())) {
                                toFill.add(i);
                                done.addAll(i.getAllConnected());
                        }
                }

                if (fillOnlyItems != null) {
                        for (Item i : fillOnlyItems) {
                                if (done.contains(i)) {
                                        continue;
                                } else if (!DisplayController.isAudienceMode() || !i.isConnectedToAnnotation()) {
                                        toFill.add(i);
                                }
                                done.addAll(i.getAllConnected());
                        }
                }

                // Sort the items to fill
                Collections.sort(toFill, new Comparator<Item>() {
                        @Override
                        public int compare(Item a, Item b) {
                                Double aArea = a.getEnclosedArea();
                                Double bArea = b.getEnclosedArea();
                                int cmp = aArea.compareTo(bArea);
                                if (cmp == 0) {
                                        // Shapes to the left go underneath
                                        PolygonBounds pA = a.getEnclosedShape();
                                        PolygonBounds pB = b.getEnclosedShape();
                                        if (pA == null || pB == null) {
                                                return 0;
                                        }
                                        return new Integer(pA.getMinX()).compareTo(pB.getMinX());
                                }
                                return cmp * -1;
                        }
                });
                
                for (Item i : toFill) {
                        if (i instanceof XRayable) {
                                PaintItem(i);
                        } else {
                                // Paint the fill and lines
                                i.paintFill();
                                List<Line> lines = i.getLines();
                                if (lines.size() > 0) {
                                        PaintItem(lines.get(0));
                                }
                        }
                }
        }

        /** Displays the given Item on the screen. */
        public static void PaintItem(Item i)
        {
                if (i == null) {
                        return;
                }

                // do not paint annotation items in audience mode
                if (!DisplayController.isAudienceMode() || (!i.isConnectedToAnnotation() && !i.isAnnotation()) || i == FrameUtils.getLastEdited())
                {
                        i.paint();
                }
        }

        /**
         * Highlights an item on the screen Note: All graphics are handled by the
         * Item itself.
         * 
         * @param i
         *            The Item to highlight.
         * @param val
         *            True if the highlighting is being shown, false if it is being
         *            erased.
         * @return the item that was highlighted
         */
        public static Item Highlight(Item i) {
                if ((i instanceof Line)) {
                        // Check if within 20% of the end of the line
                        Line l = (Line) i;
                        Item toDisconnect = l.getEndPointToDisconnect(DisplayController.getMousePosition());

                        // Brook: Widget Edges do not have such a context
                        if (toDisconnect != null && !(i instanceof WidgetEdge)) {
                                Item.HighlightMode newMode = toDisconnect.getHighlightMode();
                                if (FreeItems.hasItemsAttachedToCursor()) {
                                        newMode = Item.HighlightMode.Normal;
                                }
                                // unhighlight all the other dots
                                for (Item conn : toDisconnect.getAllConnected()) {
                                        conn.setHighlightMode(Item.HighlightMode.None);
                                        conn.setHighlightColorToDefault();
                                }
                                l.setHighlightMode(newMode);
                                l.setHighlightColorToDefault();
                                // highlight the dot that will be in disconnect mode
                                toDisconnect.setHighlightMode(newMode);
                                toDisconnect.setHighlightColorToDefault();
                                i = toDisconnect;
                        } else {
                                if (StandardInputEventListeners.kbmStateListener.isKeyDown(Key.SHIFT)) {
                                        for(Item j : i.getAllConnected()) {
                                        if(j instanceof Dot && !j.equals(i)) {
                                                j.setHighlightMode(HighlightMode.None);
                                                j.setHighlightColorToDefault();
                                        }
                                }
                                l.getStartItem().setHighlightMode(HighlightMode.Connected);
                                l.getStartItem().setHighlightColorToDefault();
                                l.getEndItem().setHighlightMode(HighlightMode.Connected);
                                l.getEndItem().setHighlightColorToDefault();
                        } else {
                                for(Item j : i.getAllConnected()) {
                                        if(j instanceof Dot && !j.equals(i)) {
                                                j.setHighlightMode(HighlightMode.Connected);
                                                j.setHighlightColorToDefault();
                                        }
                                }
                        }
//                              Collection<Item> connected = i.getAllConnected();
//                              for (Item conn : connected) {
//                                      conn.setHighlightMode(Item.HighlightMode.Connected);
//                              }
                        }
                } else if (i instanceof Circle) {
                        i.setHighlightMode(Item.HighlightMode.Connected);
                        i.setHighlightColorToDefault();
                } else if (!i.isVisible()) {
                        changeHighlightMode(i, Item.HighlightMode.Connected, null);
                } else if (i instanceof Dot) {
                        // highlight the dot
                        if (i.hasPermission(UserAppliedPermission.full)) {
                                changeHighlightMode(i, Item.HighlightMode.Normal, Item.HighlightMode.None);
                        } else {
                                changeHighlightMode(i, Item.HighlightMode.Connected, Item.HighlightMode.Connected);
                        }
                        // highlight connected dots, but only if there aren't items being carried on the cursor
                        if(FreeItems.getInstance().size() == 0) {
                        if (StandardInputEventListeners.kbmStateListener.isKeyDown(Key.SHIFT)) {
                                for(Item j : i.getAllConnected()) {
                                        if(j instanceof Dot && !j.equals(i)) {
                                                j.setHighlightMode(HighlightMode.Connected);
                                                j.setHighlightColorToDefault();
                                        }
                                }
                        } else {
                                for(Item j : i.getAllConnected()) {
                                        if(j instanceof Dot && !j.equals(i)) {
                                                j.setHighlightMode(HighlightMode.None);
                                                j.setHighlightColorToDefault();
                                        }
                                }
                                for(Line l : i.getLines()) {
                                        Item j = l.getOppositeEnd(i);
                                        j.setHighlightMode(HighlightMode.Connected);
                                        j.setHighlightColorToDefault();
                                }
                        }
                        }
        } else {
                        // FrameGraphics.ChangeSelectionMode(i,
                        // Item.SelectedMode.Normal);
                        // For polygons need to make sure all other endpoints are
                        // unHighlighted
                        if (i.hasPermission(UserAppliedPermission.full)) {
                                changeHighlightMode(i, Item.HighlightMode.Normal, Item.HighlightMode.None);
                        } else {
                                changeHighlightMode(i, Item.HighlightMode.Connected, Item.HighlightMode.Connected);
                        }
                }
                DisplayController.requestRefresh(true);
                return i;
        }

        public static void changeHighlightMode(Item item, Item.HighlightMode newMode)
        {
                changeHighlightMode(item, newMode, newMode);
        }

        public static void changeHighlightMode(Item item, Item.HighlightMode newMode, Item.HighlightMode connectedNewMode)
        {
                if (item == null) {
                        return;
                }

                if (item.hasVector()) {
                        for (Item i : item.getParentOrCurrentFrame().getVectorItems()) {
                                if (i.getEditTarget() == item) {
                                        i.setHighlightMode(newMode);
                                        i.setHighlightColorToDefault();
                                }
                        }
                        item.setHighlightMode(newMode);
                        item.setHighlightColorToDefault();
                } else {
                        // Mike: TODO comment on why the line below is used!!
                        // I forgot already!! Oops
                        boolean freeItem = FreeItems.getInstance().contains(item);
                        for (Item i : item.getAllConnected()) {
                                if (/* freeItem || */!FreeItems.getInstance().contains(i)) {
                                        i.setHighlightMode(connectedNewMode);
                                        i.setHighlightColorToDefault();
                                }
                        }
                        if (!freeItem && newMode != connectedNewMode) {
                                item.setHighlightMode(newMode);
                                item.setHighlightColorToDefault();
                        }
                }
                DisplayController.requestRefresh(true);
        }

        /*
         * 
         * FrameRenderPass stuff. (TODO: Not sure if this is used for anything? In Apollo. cts16)
         * 
         */
        
        /**
         * Adds a FinalFrameRenderPass to the frame-render pipeline...
         * 
         * Note that the last added FinalFrameRenderPass will be rendered at the
         * very top.
         * 
         * @param pass
         *            The pass to add. If already added then nothing results in the
         *            call.
         * 
         * @throws NullPointerException
         *             If pass is null.
         */
        public static void addFrameRenderPass(FrameRenderPass pass) {
                if (pass == null) {
                        throw new NullPointerException("pass");
                }

                if (!_frameRenderPasses.contains(pass)) {
                        _frameRenderPasses.add(pass);
                }
        }

        /**
         * Adds a FinalFrameRenderPass to the frame-render pipeline...
         * 
         * Note that the last added FinalFrameRenderPass will be rendered at the
         * very top.
         * 
         * @param pass
         *            The pass to remove
         * 
         */
        public static void removeFrameRenderPass(FrameRenderPass pass) {
                _frameRenderPasses.remove(pass);
        }

        /**
         * A FinalFrameRenderPass is invoked at the very final stages for rendering
         * a frame: that is, after the popups are drawn.
         * 
         * There can be many applications for FinalFrameRenderPass. Such as tool
         * tips, balloons, or drawing items at the highest Z-order in special
         * situations.
         * 
         * Although if there are multiples FinalFrameRenderPasses attach to the
         * frame painter then it is not guaranteed to be rendered very last.
         * 
         * @see FrameGraphics#addFinalFrameRenderPass(org.expeditee.gui.FrameGraphics.FrameRenderPass)
         * @see FrameGraphics#removeFinalFrameRenderPass(org.expeditee.gui.FrameGraphics.FrameRenderPass)
         * 
         * @author Brook Novak
         */
        public interface FrameRenderPass {

                /**
                 * 
                 * @param currentClip
                 * 
                 * @return The clip that the pass should use instead. i.e. if there are
                 *         any effects that cannot invalidate prior to paint call.
                 */
                Clip paintStarted(Clip currentClip);

                void paintFinalPass();

                void paintPreLayeredPanePass();
        }

}