/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
package org.netbeans.modules.java.graph;

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.Stroke;
import java.awt.event.ActionEvent;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;
import java.util.concurrent.atomic.AtomicBoolean;
import javax.swing.AbstractAction;
import javax.swing.Action;
import javax.swing.Icon;
import javax.swing.JMenu;
import javax.swing.JPopupMenu;
import javax.swing.JScrollPane;
import javax.swing.JSeparator;
import javax.swing.filechooser.FileNameExtensionFilter;
import org.netbeans.api.annotations.common.CheckForNull;
import org.netbeans.api.annotations.common.NullAllowed;
import org.netbeans.api.visual.action.ActionFactory;
import org.netbeans.api.visual.action.EditProvider;
import org.netbeans.api.visual.action.MoveProvider;
import org.netbeans.api.visual.action.PopupMenuProvider;
import org.netbeans.api.visual.action.SelectProvider;
import org.netbeans.api.visual.action.TwoStateHoverProvider;
import org.netbeans.api.visual.action.WidgetAction;
import org.netbeans.api.visual.anchor.AnchorFactory;
import org.netbeans.api.visual.animator.AnimatorEvent;
import org.netbeans.api.visual.animator.AnimatorListener;
import org.netbeans.api.visual.export.SceneExporter;
import org.netbeans.api.visual.graph.GraphScene;
import org.netbeans.api.visual.graph.layout.GraphLayout;
import org.netbeans.api.visual.graph.layout.GraphLayoutFactory;
import org.netbeans.api.visual.graph.layout.GraphLayoutSupport;
import org.netbeans.api.visual.layout.SceneLayout;
import org.netbeans.api.visual.model.ObjectState;
import org.netbeans.api.visual.widget.ConnectionWidget;
import org.netbeans.api.visual.widget.LayerWidget;
import org.netbeans.api.visual.widget.Widget;
import org.openide.filesystems.FileChooserBuilder;
import org.openide.util.Exceptions;
import org.openide.util.NbBundle.Messages;

/**
 *
 * @author Milos Kleint 
 * @param <I> 
 */
public class DependencyGraphScene<I extends GraphNodeImplementation> extends GraphScene<GraphNode<I>, GraphEdge<I>> {
    
    
    public interface PaintingProvider<I extends GraphNodeImplementation> {        
        /**
         * Determines an icon for the given node.
         * 
         * @param node
         * @return the icon or <code>null</code> if none should be used
         */
        Icon getIcon(I node);
        
        /**
         * Determines if the given node should be visible.
         * 
         * @param node
         * @return <code>true</code> if the node should be visible, otherwise <code>false</code>
         */
        boolean isVisible(I node);
        
        /**
         * Determines if the given edge should be visible.
         * 
         * @param source
         * @param target
         * @return <code>true</code> if the edge should be visible, otherwise <code>false</code>
         */
        boolean isVisible(I source, I target);
        
        /**
         * Determines a color for the given node.
         * 
         * @param node
         * @return the color or <code>null</code> if default should be used
         */
        Color getColor(I node);
        
        /**
         * Determines a stroke for the given edge.
         * 
         * @param source
         * @param target
         * @return the stroke or <code>null</code> if default should be used
         */
        Stroke getStroke(I source, I target);
    }
        
    public interface HighlightDepthProvider {
        int getDepth();
    }
    
    public interface VersionProvider<I extends GraphNodeImplementation> {        
        // conflict type
        public static final int VERSION_NO_CONFLICT = 0;
        public static final int VERSION_POTENTIAL_CONFLICT = 1;
        public static final int VERSION_CONFLICT = 2;
    
        String getVersion(I impl);    
        int compareVersions(I impl1, I impl2);
        boolean isIncluded(I impl);
        boolean isOmmitedForConflict(I impl);
    }
    
    public interface ActionsProvider<I extends GraphNodeImplementation> {
        Action createFixVersionConflictAction(DependencyGraphScene scene, GraphNode<I> rootNode, GraphNode<I> node);
        Action createExcludeDepAction(DependencyGraphScene scene, GraphNode<I> rootNode, GraphNode<I> node);
        Action createShowGraphAction(GraphNode<I> node);
    }
    
    private final VersionProvider versionProvider;
    private final ActionsProvider nodeActionProvider;
    private final HighlightDepthProvider highlightProvider;
    private final PaintingProvider<I> paintingProvider;
    
    private LayerWidget mainLayer;
    private final LayerWidget connectionLayer;
    private GraphNode rootNode;
    private final AllActionsProvider allActionsP = new AllActionsProvider();
    
//    private GraphLayout layout;
    private final WidgetAction moveAction = ActionFactory.createMoveAction(null, allActionsP);
    private final WidgetAction popupMenuAction = ActionFactory.createPopupMenuAction(allActionsP);
    private final WidgetAction zoomAction = ActionFactory.createMouseCenteredZoomAction(1.1);
    private final WidgetAction panAction = ActionFactory.createPanAction();
    private final WidgetAction editAction = ActionFactory.createEditAction(allActionsP);
    private final WidgetAction hoverAction = ActionFactory.createHoverAction(new HoverController());

    private final Action sceneZoomToFitAction = new SceneZoomToFitAction();
    private final Action highlitedZoomToFitAction = new HighlightedZoomToFitAction();

    private FruchtermanReingoldLayout layout;
    private int maxDepth = 0;
    private FitToViewLayout fitViewL;

    private static final Set<GraphNode> EMPTY_SELECTION = new HashSet<>();
    private JScrollPane pane;
    private final AtomicBoolean animated = new AtomicBoolean(false);
    
    private HighlightVisitor highlightV;
    
    public DependencyGraphScene(JScrollPane pane) {
        this(null, null, null, null);
    }
    
    public DependencyGraphScene(ActionsProvider<I> nodeActionProvider, HighlightDepthProvider highlightProvider, VersionProvider<I> versionProvider, PaintingProvider<I> paintingProvider) {                
        this.nodeActionProvider = nodeActionProvider;
        this.highlightProvider = highlightProvider;
        this.versionProvider = versionProvider;
        this.paintingProvider = paintingProvider;
        
        mainLayer = new LayerWidget(this);
        addChild(mainLayer);
        connectionLayer = new LayerWidget(this);
        addChild(connectionLayer);
        
        //this glasspane thing is only here to get rid of connection lines across widgets
        Widget glasspane = new LayerWidget(this) {

            @Override
            protected void paintChildren() {
                if (isCheckClipping()) {
                    Rectangle clipBounds = DependencyGraphScene.this.getGraphics().getClipBounds();
                    for (Widget child : mainLayer.getChildren()) {
                        Point location = child.getLocation();
                        Rectangle bounds = child.getBounds();
                        bounds.translate(location.x, location.y);
                        if (clipBounds == null || bounds.intersects(clipBounds)) {
                            child.paint();
                        }
                    }
                } else {
                    for (Widget child : mainLayer.getChildren()) {
                        child.paint();
                    }
                }
            }

        };
        addChild(glasspane);
        //getActions().addAction(this.createObjectHoverAction());
        getActions().addAction(hoverAction);
        getActions().addAction(ActionFactory.createSelectAction(allActionsP));
        getActions().addAction(zoomAction);
        getActions().addAction(panAction);
        getActions().addAction(editAction);
        getActions().addAction(popupMenuAction);
    }

    boolean isVisible(GraphEdge<I> e) {
        return paintingProvider == null || paintingProvider.isVisible(e.getSource(), e.getTarget());
    }   
    
    boolean isVisible(GraphNode<I> n) {
        return paintingProvider == null || paintingProvider.isVisible(n.getImpl());
    }
    
    Stroke getStroke(GraphEdge<I> e) {
        return paintingProvider != null ? paintingProvider.getStroke(e.getSource(), e.getTarget()) : null;
    }
    
    Color getColor(GraphNode<I> n) {
        return paintingProvider != null ? paintingProvider.getColor(n.getImpl()) : null;
    }
    
    Icon getIcon(GraphNode<I> n) {
        return paintingProvider != null ? paintingProvider.getIcon(n.getImpl()) : null;
    }
    
    public void addGraphNodeImpl(I d) {
        super.addNode(new GraphNode<>(d));
    }
    
    public GraphEdge addEdge(I source, I target) {
        Collection<GraphNode<I>> nodes = getNodes();
        GraphNode<I> s = getGraphNode(nodes, source);
        assert s != null;
        GraphNode<I> t = getGraphNode(nodes, target);
        assert t != null;
        GraphEdge<I> edge = new GraphEdge<>(source, target);
        addEdge(edge);
        setEdgeSource(edge, s);
        setEdgeTarget(edge, t);
        return edge;
    }
    
    private GraphNode<I> getGraphNode(Collection<GraphNode<I>> nodes, I i) {
        for(GraphNode<I> n : nodes) {
            if(n.getImpl().equals(i)) {
                return n;
            }
        }
        assert false : "no node found for " + i.getName();
        return null;
    }

    public void setSearchString(String val) {
        SearchVisitor visitor = new SearchVisitor(this);
        visitor.setSearchString(val);
        visitor.accept(getRootGraphNode().getImpl());
        validate();
        repaint();
        revalidate();
        repaint();
    }
    
    public void notifyModelChanged(GraphNode<I> graphNode) {
        NodeWidget nodeWidget = (NodeWidget) findWidget(graphNode);
        if (nodeWidget != null) {
            nodeWidget.modelChanged();
        }
    }
    
    public void notifyModelChanged(GraphEdge<I> graphEdge) {
        EdgeWidget edgeWidget = (EdgeWidget) findWidget(graphEdge);
        if (edgeWidget != null) {
            edgeWidget.modelChanged();
        }
    }
    
    boolean supportsVersions () {
        return versionProvider != null;
    }    
    
    public boolean isIncluded(I node) {
        if(!supportsVersions()) {
            return true;
        }
        assert versionProvider != null;
        return versionProvider.isIncluded(node);
    }
    
    boolean isConflict(I node) {
        if(!supportsVersions()) {
            return false;
        }
        assert versionProvider != null;
        return versionProvider.isOmmitedForConflict(node);        
    }
            
    String getVersion(I impl) {
        assert versionProvider != null;
        return versionProvider.getVersion(impl);
    } 

    int compareVersions(I n1, I n2) {
        assert versionProvider != null;
        return versionProvider.compareVersions(n1, n2);        
    }
    
    public void setMyZoomFactor(double zoom) {
        setZoomFactor(zoom);
        ArrayList<Widget> arr = new ArrayList<Widget>();
        arr.addAll(mainLayer.getChildren());
        arr.addAll(connectionLayer.getChildren());
        for (Widget wid : arr) {
            if (wid instanceof NodeWidget) {
                ((NodeWidget)wid).updateReadableZoom();
            }
            if (wid instanceof EdgeWidget) {
                ((EdgeWidget)wid).updateReadableZoom();
            }
        }
    }

    public void initialLayout() {
        //start using default layout
        layout =  new FruchtermanReingoldLayout(this, pane);
        layout.invokeLayout();
        addSceneListener(new SceneListener() {

            @Override
            public void sceneRepaint() {
               
            }

            @Override
            public void sceneValidating() {
                
            }

            @Override
            public void sceneValidated() {
                //the first layout has not be non animated, then we can fit to zoom easily
                if (animated.compareAndSet(false, true)) {
                    new SceneZoomToFitAction().actionPerformed(null);
                }
                    
            }
        });
    }
    
    public void setSurroundingScrollPane(JScrollPane pane) {
        this.pane = pane; 
    }
    
    public GraphNode<I> getRootGraphNode() {
        return rootNode;
    }

    public int getMaxNodeDepth() {
        return maxDepth;
    }

    boolean isAnimated () {
        return animated.get();
    }

    @CheckForNull public GraphNode getGraphNodeRepresentant(GraphNodeImplementation impl) {
        for (GraphNode grnode : getNodes()) {
            if (grnode.getImpl().equals(impl)) {
                return grnode;                
            }
            if(supportsVersions() && (grnode.represents(impl))) { 
                return grnode;            
            }
        }
        return null;
    }
    
    @Override protected Widget attachNodeWidget(GraphNode node) {
        if (rootNode == null) {
            rootNode = node;
        }
        if (node.getPrimaryLevel() > maxDepth) {
            maxDepth = node.getPrimaryLevel();
        }
        
        Action fixAction = nodeActionProvider != null ? nodeActionProvider.createFixVersionConflictAction(this, rootNode, node) : null;        
        NodeWidget root = new NodeWidget(this, node, fixAction, hoverAction);
        mainLayer.addChild(root);
        root.setOpaque(true);
        
        root.getActions().addAction(this.createObjectHoverAction());
        root.getActions().addAction(this.createSelectAction());
        root.getActions().addAction(moveAction);
        root.getActions().addAction(editAction);
        root.getActions().addAction(popupMenuAction);
                    
        return root;
    }
    
    @Override protected Widget attachEdgeWidget(GraphEdge edge) {
        EdgeWidget connectionWidget = new EdgeWidget(this, edge);
        connectionLayer.addChild(connectionWidget);
        return connectionWidget;
    }
    
    @Override protected void attachEdgeSourceAnchor(GraphEdge edge,
            GraphNode oldsource,
            GraphNode source) {
        ((ConnectionWidget) findWidget(edge)).setSourceAnchor(AnchorFactory.createRectangularAnchor(findWidget(source)));
        
    }
    
    @Override protected void attachEdgeTargetAnchor(GraphEdge edge,
            GraphNode oldtarget,
            GraphNode target) {
        NodeWidget wid = (NodeWidget)findWidget(target);
        ((ConnectionWidget) findWidget(edge)).setTargetAnchor(AnchorFactory.createRectangularAnchor(wid));
    }    
    
    public void updateVisibility() {
        getEdges().stream().forEach(edge -> ((EdgeWidget)findWidget(edge)).updateAppearance(true));
        getNodes().stream().forEach(node -> ((NodeWidget)findWidget(node)).updatePaintContent());
    }
    
    public void calculatePrimaryPathsAndLevels() {
        Collection<GraphNode<I>> ns = getNodes();        
        for (GraphNode<I> n : ns) {
            List<GraphEdge> primaryPathEdges = new ArrayList<>();
            LinkedList<GraphNode> importantNodes = new LinkedList<>(); // XXX node depth?
            addPathToRoot(n, primaryPathEdges, importantNodes);
            for (GraphEdge pe : primaryPathEdges) {
                pe.setPrimaryPath(true);
                }
            int level = primaryPathEdges.size();
            n.setPrimaryLevel(level);
            if (level > maxDepth) {
                maxDepth = level;
            }
        }
    }
    
    void highlightRelated (GraphNode<I> node) {
        List<GraphNode> importantNodes = new ArrayList<GraphNode>();
        List<GraphEdge> otherPathsEdges = new ArrayList<GraphEdge>();
        List<GraphEdge> primaryPathEdges = new ArrayList<GraphEdge>();
        List<GraphNode> childrenNodes = new ArrayList<GraphNode>();
        List<GraphEdge> childrenEdges = new ArrayList<GraphEdge>();

        importantNodes.add(node);

        @SuppressWarnings("unchecked")
        List<I> children = node.getImpl().getChildren();
        if (children != null) {
            for (I n : children) {
                GraphNode child = getGraphNodeRepresentant(n);
                if (child != null) {
                    childrenNodes.add(child);
                }
            }
        }

        childrenEdges.addAll(findNodeEdges(node, true, false));

        // primary path
        addPathToRoot(node, primaryPathEdges, importantNodes);

        if(supportsVersions()) {
            // other important paths
            ArrayList<I> representants = new ArrayList<>(node.getDuplicatesOrConflicts());
            for (GraphNodeImplementation curRep : representants) {
                addPathToRoot(curRep, curRep.getParent(), otherPathsEdges, importantNodes);
            }
        }
        EdgeWidget ew;
        for (GraphEdge curE : getEdges()) {
            ew = (EdgeWidget) findWidget(curE);
            if (primaryPathEdges.contains(curE)) {
                ew.setState(EdgeWidget.HIGHLIGHTED_PRIMARY);
            } else if (otherPathsEdges.contains(curE)) {
                ew.setState(EdgeWidget.HIGHLIGHTED);
            } else if (childrenEdges.contains(curE)) {
                ew.setState(EdgeWidget.GRAYED);
            } else {
                ew.setState(EdgeWidget.DISABLED);
            }
        }

        NodeWidget aw;
        for (GraphNode curN : getNodes()) {
            aw = (NodeWidget) findWidget(curN);
            if (importantNodes.contains(curN)) {
                aw.setPaintState(EdgeWidget.REGULAR);
                aw.setReadable(true);
            } else if (childrenNodes.contains(curN)) {
                aw.setPaintState(EdgeWidget.REGULAR);
                aw.setReadable(true);
            } else {
                aw.setPaintState(EdgeWidget.DISABLED);
                aw.setReadable(false);
            }
        }

    }

    private void addPathToRoot(GraphNode node, List<GraphEdge> edges, List<GraphNode> nodes) {
        GraphNodeImplementation parentImpl = node.getParent();
        addPathToRoot(node.getImpl(), parentImpl, edges, nodes);
    }


    private void addPathToRoot(GraphNodeImplementation impl, GraphNodeImplementation parentImpl, List<GraphEdge> edges, List<GraphNode> nodes) {
        final Set<GraphNodeImplementation> seen = new HashSet<>();
        GraphNode grNode;
        while (parentImpl != null) {
            seen.add(parentImpl);
            grNode = getGraphNodeRepresentant(parentImpl);
            if (grNode == null) {
                return;
            }
            GraphNode targetNode = getGraphNodeRepresentant(impl);
            if (targetNode == null) {
                return;
            }
            edges.addAll(findEdgesBetween(grNode, targetNode));
            nodes.add(grNode);
            impl = parentImpl;
            parentImpl = grNode.getParent();
            if (seen.contains(parentImpl)) {
                parentImpl = null;
            }
        }
    }

    private class AllActionsProvider implements PopupMenuProvider, 
            MoveProvider, EditProvider, SelectProvider {

        private Point moveStart;

/*        public void select(Widget wid, Point arg1, boolean arg2) {
            System.out.println("select called...");
            Widget w = wid;
            while (w != null) {
                GraphNode node = (GraphNode)findObject(w);
                if (node != null) {
                    setSelectedObjects(Collections.singleton(node));
                    System.out.println("selected object: " + node.getArtifact().getArtifact().getArtifactId());
                    highlightRelated(node);
                    ((NodeWidget)w).setSelected(true);
                    return;
                }
                w = w.getParentWidget();
            }
        }*/
        
        @Messages({
            "ACT_Export_As_Image=Export As Image",
            "ACT_LayoutSubMenu=Layout",
            "ACT_Export_As_Image_Title=Export Dependency Graph As PNG"
        })
        @Override public JPopupMenu getPopupMenu(Widget widget, Point localLocation) {
            JPopupMenu popupMenu = new JPopupMenu();
            if (widget == DependencyGraphScene.this) {
                popupMenu.add(sceneZoomToFitAction);
                final JMenu layoutMenu = new JMenu(Bundle.ACT_LayoutSubMenu());
                popupMenu.add(layoutMenu);
                layoutMenu.add(new FruchtermanReingoldLayoutAction());
                layoutMenu.add(new JSeparator());
                layoutMenu.add(new HierarchicalGraphLayoutAction());
                layoutMenu.add(new TreeGraphLayoutVerticalAction());
                layoutMenu.add(new TreeGraphLayoutHorizontalAction());
                popupMenu.add(new AbstractAction(Bundle.ACT_Export_As_Image()) {
                    @Override
                    public void actionPerformed(ActionEvent e) {
                        File file = new FileChooserBuilder("DependencyGraphScene-ExportDir").setTitle(Bundle.ACT_Export_As_Image_Title())
                                .setAcceptAllFileFilterUsed(false).addFileFilter(new FileNameExtensionFilter("PNG file", "png")).showSaveDialog();
                        if (file != null) {
                            try {
                                DependencyGraphScene theScene = DependencyGraphScene.this;
                                SceneExporter.createImage(theScene, file, SceneExporter.ImageType.PNG, SceneExporter.ZoomType.CURRENT_ZOOM_LEVEL, false, false, -1, -1, -1);
                            } catch (IOException ex) {
                                Exceptions.printStackTrace(ex);
                            }
                        }
                    }
                });
            } else {
                if(nodeActionProvider != null) {
                    GraphNode node = (GraphNode)findObject(widget);
                    
                    boolean addSeparator = false;
                    Action a = nodeActionProvider.createFixVersionConflictAction(DependencyGraphScene.this, rootNode, node);
                    if(a != null) {
                        popupMenu.add(a);
                        addSeparator = true;                        
                    }
                    a = nodeActionProvider.createExcludeDepAction(DependencyGraphScene.this, rootNode, node);
                    if(a != null) {
                        popupMenu.add(a);
                        addSeparator = true;                        
                    }                    
                    if (addSeparator) {
                        popupMenu.add(new JSeparator());
                    }
                    popupMenu.add(highlitedZoomToFitAction);
                    if (!node.isRoot()) {
                        a = nodeActionProvider.createShowGraphAction(node);
                        if(a != null) {
                            popupMenu.add(a);
                        }
                    }
                }
            }
            return popupMenu;
        }

        @Override public void movementStarted(Widget widget) {
            widget.bringToFront();
            moveStart = widget.getLocation();
        }
        @Override public void movementFinished(Widget widget) {
            // little hack to call highlightRelated on mouse click while leaving
            // normal move behaviour on real dragging
            Point moveEnd = widget.getLocation();
            if (moveStart.distance(moveEnd) < 5) {
                Object obj = DependencyGraphScene.this.findObject(widget);
                if (obj instanceof GraphNode) {
                    DependencyGraphScene.this.highlightRelated((GraphNode)obj);
                }
            }
        }
        @Override public Point getOriginalLocation(Widget widget) {
            return widget.getPreferredLocation ();
        }
        @Override public void setNewLocation(Widget widget, Point location) {
            widget.setPreferredLocation (location);
        }

        @Override public void edit(Widget widget) {
            if (DependencyGraphScene.this == widget) {
                sceneZoomToFitAction.actionPerformed(null);
            } else {
                highlitedZoomToFitAction.actionPerformed(null);
            }
        }

        @Override public boolean isAimingAllowed(Widget widget, Point localLocation, boolean invertSelection) {
            return false;
        }

        @Override public boolean isSelectionAllowed(Widget widget, Point localLocation, boolean invertSelection) {
            return true;
        }

        @Override public void select(Widget widget, Point localLocation, boolean invertSelection) {
            setSelectedObjects(EMPTY_SELECTION);
            highlightDepthIntern();
        }

    }        

    /** 
     * Highlights/diminishes graph nodes and edges based on path from root depth 
     * based on the in constructor provided HighlightDepthProvider
     */
    public void highlightDepth(int depth) {
        assert depth > -1 || highlightProvider != null : "using depth highlighting without providing HighlightProvider in c'tor no allowed";
        if(depth == -1) {
            depth = 0;
        }
        if (highlightV == null) {
            highlightV = new HighlightVisitor(this);
        }
        highlightV.setMaxDepth(depth);
        highlightV.accept(getRootGraphNode().getImpl());
        validate();
        repaint();
    }
    
    public void resetHighlight() {
        highlightV = null;
    }
    
    private void highlightDepthIntern () {        
        int depth;
        if(highlightProvider == null) {
            depth = -1; // not available
        } else {
            depth = highlightProvider.getDepth();
        }
        highlightDepth(depth);
    }
    
    @Override
    protected void notifyStateChanged(ObjectState previousState, ObjectState state) {
        super.notifyStateChanged(previousState, state);

        if (!previousState.isSelected() && state.isSelected()) {
            highlightDepthIntern();
        }
    }

    private FitToViewLayout getFitToViewLayout () {
        if (fitViewL == null) {
            fitViewL = new FitToViewLayout(this, pane);
        }
        return fitViewL;
    }
        
    private static class FitToViewLayout extends SceneLayout {

        private final DependencyGraphScene depScene;
        private List<? extends Widget> widgets;
        private final JScrollPane parentScrollPane;

        FitToViewLayout(DependencyGraphScene scene, JScrollPane parentScrollPane) {
            super(scene);
            this.depScene = scene;
            this.parentScrollPane = parentScrollPane;
        }

        
        protected void fitToView(@NullAllowed List<? extends Widget> widgets) {
            this.widgets = widgets;
            this.invokeLayout(); 
        }

        @Override
        protected void performLayout() {
            Rectangle rectangle = null;
            List<? extends Widget> toFit = widgets != null ? widgets : depScene.getChildren();
            if (toFit == null) {
                return;
            }

            for (Widget widget : toFit) {
                Rectangle bounds = widget.getBounds();
                if (bounds == null) {
                    continue;
                }
                if (rectangle == null) {
                    rectangle = widget.convertLocalToScene(bounds);
                } else {
                    rectangle = rectangle.union(widget.convertLocalToScene(bounds));
                }
            }
            // margin around
            if (widgets == null) {
                rectangle.grow(5, 5);
            } else {
                rectangle.grow(25, 25);
            }
            Dimension dim = rectangle.getSize();
            Dimension viewDim = parentScrollPane.getViewportBorderBounds().getSize ();
            double zf = Math.min ((double) viewDim.width / dim.width, (double) viewDim.height / dim.height);
            if (depScene.isAnimated()) {
                if (widgets == null) {
                    depScene.getSceneAnimator().animateZoomFactor(zf);
                } else {
                    CenteredZoomAnimator cza = new CenteredZoomAnimator(depScene.getSceneAnimator());
                    cza.setZoomFactor(zf,
                            new Point((int)rectangle.getCenterX(), (int)rectangle.getCenterY()));
                }
            } else {
                depScene.setMyZoomFactor (zf);
            }
        }

    }

    private class SceneZoomToFitAction extends AbstractAction {

        @Messages("ACT_ZoomToFit=Zoom To Fit")
        SceneZoomToFitAction() {
            putValue(NAME, Bundle.ACT_ZoomToFit());
        }

        @Override public void actionPerformed(ActionEvent e) {
            DependencyGraphScene.this.getFitToViewLayout().fitToView(null);
        }
    };

    private class HighlightedZoomToFitAction extends AbstractAction {

        HighlightedZoomToFitAction() {
            putValue(NAME, Bundle.ACT_ZoomToFit());
        }

        @Override public void actionPerformed(ActionEvent e) {
            Collection<GraphNode<I>> grNodes = DependencyGraphScene.this.getNodes();
            List<NodeWidget> aws = new ArrayList<NodeWidget>();
            NodeWidget aw = null;
            int paintState;
            for (GraphNode grNode : grNodes) {
                aw = (NodeWidget) findWidget(grNode);
                paintState = aw.getPaintState();
                if (paintState != EdgeWidget.DISABLED && paintState != EdgeWidget.GRAYED) {
                    aws.add(aw);
                }
            }
            DependencyGraphScene.this.getFitToViewLayout().fitToView(aws);
        }
    };

    private static class HoverController implements TwoStateHoverProvider {

        @Override public void unsetHovering(Widget widget) {
            NodeWidget aw = findArtifactW(widget);
            if (widget != null) {
                aw.bulbUnhovered();
            }
        }

        @Override public void setHovering(Widget widget) {
            NodeWidget aw = findArtifactW(widget);
            if (aw != null) {
                aw.bulbHovered();
            }
        }

        private NodeWidget findArtifactW (Widget w) {
            while (w != null && !(w instanceof NodeWidget)) {
                w = w.getParentWidget();
            }
            return (NodeWidget)w;
        }

    }
    
    private class HierarchicalGraphLayoutAction extends AbstractAction {

       @Messages("ACT_Layout_HierarchicalGraphLayout=Hierarchical")
       HierarchicalGraphLayoutAction() {
           putValue(NAME, Bundle.ACT_Layout_HierarchicalGraphLayout());
       }

       @Override public void actionPerformed(ActionEvent e) {
           final GraphLayout layout = GraphLayoutFactory.createHierarchicalGraphLayout(DependencyGraphScene.this, DependencyGraphScene.this.isAnimated(), false);
           layout.layoutGraph(DependencyGraphScene.this);
            fitToZoomAfterLayout();
        }
   };
   private class TreeGraphLayoutVerticalAction extends AbstractAction {

       @Messages("ACT_Layout_TreeGraphLayoutVertical=Vertical Tree")
       TreeGraphLayoutVerticalAction() {
           putValue(NAME, Bundle.ACT_Layout_TreeGraphLayoutVertical());
       }

       @Override public void actionPerformed(ActionEvent e) {
           final GraphLayout layout = GraphLayoutFactory.createTreeGraphLayout(10, 10, 50, 50, true);
           GraphLayoutSupport.setTreeGraphLayoutRootNode(layout, DependencyGraphScene.this.rootNode);
           
           layout.layoutGraph(DependencyGraphScene.this);
           fitToZoomAfterLayout();
       }
   };

   private class TreeGraphLayoutHorizontalAction extends AbstractAction {

       @Messages("ACT_Layout_TreeGraphLayoutHorizontal=Horizontal Tree")
       TreeGraphLayoutHorizontalAction() {
           putValue(NAME, Bundle.ACT_Layout_TreeGraphLayoutHorizontal());
       }

       @Override public void actionPerformed(ActionEvent e) {
           final GraphLayout layout = GraphLayoutFactory.createTreeGraphLayout(10, 10, 50, 50, false);
           GraphLayoutSupport.setTreeGraphLayoutRootNode(layout, DependencyGraphScene.this.rootNode);
           
           layout.layoutGraph(DependencyGraphScene.this);
           fitToZoomAfterLayout();
           
       }
   };
   private class FruchtermanReingoldLayoutAction extends AbstractAction {

       @Messages("ACT_Layout_FruchtermanReingoldLayout=Default Layout")
       FruchtermanReingoldLayoutAction() {
           putValue(NAME, Bundle.ACT_Layout_FruchtermanReingoldLayout());
       }

       @Override public void actionPerformed(ActionEvent e) {
           //default layout in 7.3 
           layout.invokeLayout();
           fitToZoomAfterLayout();
       }
   };

    void fitToZoomAfterLayout() {
            DependencyGraphScene.this.getSceneAnimator().getPreferredLocationAnimator().addAnimatorListener(new AnimatorListener() {
                
                @Override
                public void animatorStarted(AnimatorEvent event) {
                    
                }
                
                @Override
                public void animatorReset(AnimatorEvent event) {
                    
                }
                
                @Override
                public void animatorFinished(AnimatorEvent event) {
                    DependencyGraphScene.this.getSceneAnimator().getPreferredLocationAnimator().removeAnimatorListener(this);
                    new SceneZoomToFitAction().actionPerformed(null);
                }
                
                @Override
                public void animatorPreTick(AnimatorEvent event) {
                    
                }
                
                @Override
                public void animatorPostTick(AnimatorEvent event) {
                    
                }
            });
    }
}