| /* |
| * Copyright (c) 2008, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. |
| * |
| * This code 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 |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| * |
| */ |
| package com.sun.hotspot.igv.view; |
| |
| import com.sun.hotspot.igv.view.widgets.BlockWidget; |
| import com.sun.hotspot.igv.view.widgets.LineWidget; |
| import com.sun.hotspot.igv.util.DoubleClickAction; |
| import com.sun.hotspot.igv.data.InputBlock; |
| import com.sun.hotspot.igv.data.InputNode; |
| import com.sun.hotspot.igv.graph.Connection; |
| import com.sun.hotspot.igv.graph.Diagram; |
| import com.sun.hotspot.igv.graph.Figure; |
| import com.sun.hotspot.igv.graph.InputSlot; |
| import com.sun.hotspot.igv.graph.OutputSlot; |
| import com.sun.hotspot.igv.graph.Slot; |
| import com.sun.hotspot.igv.hierarchicallayout.HierarchicalClusterLayoutManager; |
| import com.sun.hotspot.igv.hierarchicallayout.OldHierarchicalLayoutManager; |
| import com.sun.hotspot.igv.hierarchicallayout.HierarchicalLayoutManager; |
| import com.sun.hotspot.igv.view.widgets.FigureWidget; |
| import com.sun.hotspot.igv.view.widgets.InputSlotWidget; |
| import com.sun.hotspot.igv.view.widgets.OutputSlotWidget; |
| import com.sun.hotspot.igv.view.widgets.SlotWidget; |
| import com.sun.hotspot.igv.layout.LayoutGraph; |
| import com.sun.hotspot.igv.data.services.Scheduler; |
| import com.sun.hotspot.igv.data.ChangedListener; |
| import com.sun.hotspot.igv.graph.Block; |
| import com.sun.hotspot.igv.util.ColorIcon; |
| import com.sun.hotspot.igv.util.ExtendedSelectAction; |
| import java.awt.Color; |
| import java.awt.Dimension; |
| import java.awt.Point; |
| import java.awt.Rectangle; |
| import java.awt.event.ActionEvent; |
| import java.awt.event.FocusEvent; |
| import java.awt.event.FocusListener; |
| import java.awt.event.MouseEvent; |
| import java.awt.event.MouseListener; |
| import java.awt.event.MouseMotionListener; |
| import java.awt.event.MouseWheelEvent; |
| import java.awt.event.MouseWheelListener; |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| import javax.swing.AbstractAction; |
| import javax.swing.Action; |
| import javax.swing.BorderFactory; |
| import javax.swing.JComponent; |
| import javax.swing.JPopupMenu; |
| import javax.swing.JScrollPane; |
| import javax.swing.SwingUtilities; |
| import javax.swing.event.ChangeEvent; |
| import javax.swing.event.ChangeListener; |
| import javax.swing.event.UndoableEditEvent; |
| import javax.swing.undo.AbstractUndoableEdit; |
| import javax.swing.undo.CannotRedoException; |
| import javax.swing.undo.CannotUndoException; |
| import org.netbeans.api.visual.action.ActionFactory; |
| import org.netbeans.api.visual.action.PopupMenuProvider; |
| import org.netbeans.api.visual.action.RectangularSelectDecorator; |
| import org.netbeans.api.visual.action.RectangularSelectProvider; |
| import org.netbeans.api.visual.action.SelectProvider; |
| import org.netbeans.api.visual.action.WidgetAction; |
| import org.netbeans.api.visual.animator.SceneAnimator; |
| import org.netbeans.api.visual.layout.LayoutFactory; |
| import org.netbeans.api.visual.widget.ConnectionWidget; |
| import org.netbeans.api.visual.widget.LayerWidget; |
| import org.netbeans.api.visual.widget.Scene; |
| import org.netbeans.api.visual.widget.Widget; |
| import org.netbeans.api.visual.widget.LabelWidget; |
| import org.openide.awt.UndoRedo; |
| import org.openide.util.Lookup; |
| import org.openide.util.lookup.AbstractLookup; |
| import org.openide.util.lookup.InstanceContent; |
| |
| /** |
| * |
| * @author Thomas Wuerthinger |
| */ |
| public class DiagramScene extends Scene implements ChangedListener<DiagramViewModel> { |
| |
| private HashMap<Figure, FigureWidget> figureWidgets; |
| private HashMap<Slot, SlotWidget> slotWidgets; |
| private HashMap<Connection, ConnectionWidget> connectionWidgets; |
| private HashMap<InputBlock, BlockWidget> blockWidgets; |
| private Widget hoverWidget; |
| private WidgetAction hoverAction; |
| private List<FigureWidget> selectedWidgets; |
| private Lookup lookup; |
| private InstanceContent content; |
| private Action[] actions; |
| private LayerWidget connectionLayer; |
| private JScrollPane scrollPane; |
| private UndoRedo.Manager undoRedoManager; |
| private LayerWidget mainLayer; |
| private LayerWidget slotLayer; |
| private LayerWidget blockLayer; |
| private double realZoomFactor; |
| private BoundedZoomAction zoomAction; |
| private WidgetAction panAction; |
| private Widget topLeft; |
| private Widget bottomRight; |
| private LayerWidget startLayer; |
| private LabelWidget startLabel; |
| private DiagramViewModel model; |
| private DiagramViewModel modelCopy; |
| public static final int AFTER = 1; |
| public static final int BEFORE = 1; |
| public static final float ALPHA = 0.4f; |
| public static final int GRID_SIZE = 30; |
| public static final int BORDER_SIZE = 20; |
| public static final int UNDOREDO_LIMIT = 100; |
| public static final int SCROLL_UNIT_INCREMENT = 80; |
| public static final int SCROLL_BLOCK_INCREMENT = 400; |
| public static final float ZOOM_MAX_FACTOR = 3.0f; |
| public static final float ZOOM_MIN_FACTOR = 0.0f;//0.15f; |
| public static final float ZOOM_INCREMENT = 1.5f; |
| public static final int SLOT_OFFSET = 6; |
| public static final int ANIMATION_LIMIT = 40; |
| private PopupMenuProvider popupMenuProvider = new PopupMenuProvider() { |
| |
| public JPopupMenu getPopupMenu(Widget widget, Point localLocation) { |
| return DiagramScene.this.createPopupMenu(); |
| } |
| }; |
| private RectangularSelectDecorator rectangularSelectDecorator = new RectangularSelectDecorator() { |
| |
| public Widget createSelectionWidget() { |
| Widget widget = new Widget(DiagramScene.this); |
| widget.setBorder(BorderFactory.createLineBorder(Color.black, 2)); |
| widget.setForeground(Color.red); |
| return widget; |
| } |
| }; |
| private RectangularSelectProvider rectangularSelectProvider = new RectangularSelectProvider() { |
| |
| public void performSelection(Rectangle rectangle) { |
| if (rectangle.width < 0) { |
| rectangle.x += rectangle.width; |
| rectangle.width *= -1; |
| } |
| |
| if (rectangle.height < 0) { |
| rectangle.y += rectangle.height; |
| rectangle.height *= -1; |
| } |
| |
| boolean updated = false; |
| for (Figure f : getModel().getDiagramToView().getFigures()) { |
| FigureWidget w = figureWidgets.get(f); |
| Rectangle r = new Rectangle(w.getBounds()); |
| r.setLocation(w.getLocation()); |
| if (r.intersects(rectangle)) { |
| if (!selectedWidgets.contains(w)) { |
| addToSelection(w); |
| updated = true; |
| } |
| } else { |
| if (selectedWidgets.contains(w)) { |
| selectedWidgets.remove(w); |
| content.remove(w.getNode()); |
| w.setState(w.getState().deriveSelected(false)); |
| updated = true; |
| } |
| } |
| } |
| |
| if (updated) { |
| selectionUpdated(); |
| } |
| } |
| }; |
| private SelectProvider selectProvider = new SelectProvider() { |
| |
| public boolean isAimingAllowed(Widget widget, Point point, boolean b) { |
| return false; |
| } |
| |
| public boolean isSelectionAllowed(Widget widget, Point point, boolean b) { |
| return widget instanceof FigureWidget || widget == DiagramScene.this; |
| } |
| |
| public void select(Widget w, Point point, boolean change) { |
| |
| boolean updated = false; |
| |
| if (w == DiagramScene.this) { |
| if (DiagramScene.this.selectedWidgets.size() != 0) { |
| clearSelection(); |
| selectionUpdated(); |
| } |
| return; |
| } |
| |
| FigureWidget widget = (FigureWidget) w; |
| |
| |
| if (change) { |
| if (widget.getState().isSelected()) { |
| assert selectedWidgets.contains(widget); |
| widget.setState(widget.getState().deriveSelected(false)); |
| selectedWidgets.remove(widget); |
| content.remove(widget.getNode()); |
| updated = true; |
| } else { |
| assert !selectedWidgets.contains(widget); |
| addToSelection(widget); |
| updated = true; |
| assert widget.getState().isSelected(); |
| } |
| } else { |
| |
| if (widget.getState().isSelected()) { |
| assert selectedWidgets.contains(widget); |
| } else { |
| |
| assert !selectedWidgets.contains(widget); |
| clearSelection(); |
| addToSelection(widget); |
| updated = true; |
| assert widget.getState().isSelected(); |
| } |
| } |
| |
| if (updated) { |
| selectionUpdated(); |
| } |
| |
| } |
| }; |
| |
| private FigureWidget getFigureWidget(Figure f) { |
| return figureWidgets.get(f); |
| } |
| private FocusListener focusListener = new FocusListener() { |
| |
| public void focusGained(FocusEvent e) { |
| DiagramScene.this.getView().requestFocus(); |
| } |
| |
| public void focusLost(FocusEvent e) { |
| } |
| }; |
| private MouseWheelListener mouseWheelListener = new MouseWheelListener() { |
| |
| public void mouseWheelMoved(MouseWheelEvent e) { |
| DiagramScene.this.zoomAction.mouseWheelMoved(DiagramScene.this, new WidgetAction.WidgetMouseWheelEvent(0, e)); |
| DiagramScene.this.validate(); |
| } |
| }; |
| private MouseListener mouseListener = new MouseListener() { |
| |
| public void mouseClicked(MouseEvent e) { |
| DiagramScene.this.panAction.mouseClicked(DiagramScene.this, new WidgetAction.WidgetMouseEvent(0, e)); |
| } |
| |
| public void mousePressed(MouseEvent e) { |
| DiagramScene.this.panAction.mousePressed(DiagramScene.this, new WidgetAction.WidgetMouseEvent(0, e)); |
| } |
| |
| public void mouseReleased(MouseEvent e) { |
| DiagramScene.this.panAction.mouseReleased(DiagramScene.this, new WidgetAction.WidgetMouseEvent(0, e)); |
| } |
| |
| public void mouseEntered(MouseEvent e) { |
| DiagramScene.this.panAction.mouseEntered(DiagramScene.this, new WidgetAction.WidgetMouseEvent(0, e)); |
| } |
| |
| public void mouseExited(MouseEvent e) { |
| DiagramScene.this.panAction.mouseExited(DiagramScene.this, new WidgetAction.WidgetMouseEvent(0, e)); |
| } |
| }; |
| private MouseMotionListener mouseMotionListener = new MouseMotionListener() { |
| |
| public void mouseDragged(MouseEvent e) { |
| DiagramScene.this.panAction.mouseDragged(DiagramScene.this, new WidgetAction.WidgetMouseEvent(0, e)); |
| } |
| |
| public void mouseMoved(MouseEvent e) { |
| } |
| }; |
| private ScrollChangeListener scrollChangeListener = new ScrollChangeListener(); |
| |
| private class ScrollChangeListener implements ChangeListener { |
| |
| private Map<Widget, Point> relativePositions = new HashMap<Widget, Point>(); |
| private Point oldPosition; |
| |
| public void register(Widget w, Point p) { |
| relativePositions.put(w, p); |
| } |
| |
| public void unregister(Widget w) { |
| relativePositions.remove(w); |
| } |
| |
| public void stateChanged(ChangeEvent e) { |
| Point p = DiagramScene.this.getScrollPane().getViewport().getViewPosition(); |
| if (oldPosition == null || !p.equals(oldPosition)) { |
| for (Widget w : relativePositions.keySet()) { |
| Point curPoint = relativePositions.get(w); |
| Point newPoint = new Point(p.x + curPoint.x, p.y + curPoint.y); |
| w.setPreferredLocation(newPoint); |
| DiagramScene.this.validate(); |
| } |
| oldPosition = p; |
| } |
| } |
| } |
| |
| public Point getScrollPosition() { |
| return getScrollPane().getViewport().getViewPosition(); |
| } |
| |
| public void setScrollPosition(Point p) { |
| getScrollPane().getViewport().setViewPosition(p); |
| } |
| |
| public DiagramScene(Action[] actions, DiagramViewModel model) { |
| this.actions = actions; |
| selectedWidgets = new ArrayList<FigureWidget>(); |
| content = new InstanceContent(); |
| lookup = new AbstractLookup(content); |
| this.setCheckClipping(true); |
| this.getInputBindings().setZoomActionModifiers(0); |
| |
| JComponent comp = this.createView(); |
| comp.setDoubleBuffered(true); |
| comp.setBackground(Color.WHITE); |
| comp.setOpaque(true); |
| |
| this.setBackground(Color.WHITE); |
| this.setOpaque(true); |
| scrollPane = new JScrollPane(comp); |
| scrollPane.setBackground(Color.WHITE); |
| scrollPane.getVerticalScrollBar().setUnitIncrement(SCROLL_UNIT_INCREMENT); |
| scrollPane.getVerticalScrollBar().setBlockIncrement(SCROLL_BLOCK_INCREMENT); |
| scrollPane.getHorizontalScrollBar().setUnitIncrement(SCROLL_UNIT_INCREMENT); |
| scrollPane.getHorizontalScrollBar().setBlockIncrement(SCROLL_BLOCK_INCREMENT); |
| scrollPane.getViewport().addChangeListener(scrollChangeListener); |
| hoverAction = this.createWidgetHoverAction(); |
| |
| blockLayer = new LayerWidget(this); |
| this.addChild(blockLayer); |
| |
| startLayer = new LayerWidget(this); |
| this.addChild(startLayer); |
| // TODO: String startLabelString = "Loading graph with " + originalDiagram.getFigures().size() + " figures and " + originalDiagram.getConnections().size() + " connections..."; |
| String startLabelString = ""; |
| LabelWidget w = new LabelWidget(this, startLabelString); |
| scrollChangeListener.register(w, new Point(10, 10)); |
| w.setAlignment(LabelWidget.Alignment.CENTER); |
| startLabel = w; |
| startLayer.addChild(w); |
| |
| mainLayer = new LayerWidget(this); |
| this.addChild(mainLayer); |
| |
| topLeft = new Widget(this); |
| topLeft.setPreferredLocation(new Point(-BORDER_SIZE, -BORDER_SIZE)); |
| this.addChild(topLeft); |
| |
| |
| bottomRight = new Widget(this); |
| bottomRight.setPreferredLocation(new Point(-BORDER_SIZE, -BORDER_SIZE)); |
| this.addChild(bottomRight); |
| |
| slotLayer = new LayerWidget(this); |
| this.addChild(slotLayer); |
| |
| connectionLayer = new LayerWidget(this); |
| this.addChild(connectionLayer); |
| |
| LayerWidget selectionLayer = new LayerWidget(this); |
| this.addChild(selectionLayer); |
| |
| this.setLayout(LayoutFactory.createAbsoluteLayout()); |
| |
| this.getActions().addAction(hoverAction); |
| zoomAction = new BoundedZoomAction(1.1, false); |
| zoomAction.setMaxFactor(ZOOM_MAX_FACTOR); |
| zoomAction.setMinFactor(ZOOM_MIN_FACTOR); |
| this.getActions().addAction(ActionFactory.createMouseCenteredZoomAction(1.1)); |
| panAction = new ExtendedPanAction(); |
| this.getActions().addAction(panAction); |
| this.getActions().addAction(ActionFactory.createPopupMenuAction(popupMenuProvider)); |
| |
| LayerWidget selectLayer = new LayerWidget(this); |
| this.addChild(selectLayer); |
| this.getActions().addAction(ActionFactory.createRectangularSelectAction(rectangularSelectDecorator, selectLayer, rectangularSelectProvider)); |
| |
| blockWidgets = new HashMap<InputBlock, BlockWidget>(); |
| |
| boolean b = this.getUndoRedoEnabled(); |
| this.setUndoRedoEnabled(false); |
| this.setNewModel(model); |
| this.setUndoRedoEnabled(b); |
| } |
| |
| private void selectionUpdated() { |
| getModel().setSelectedNodes(this.getSelectedNodes()); |
| addUndo(); |
| } |
| |
| public DiagramViewModel getModel() { |
| return model; |
| } |
| |
| public void setRealZoomFactor(double d) { |
| this.realZoomFactor = d; |
| } |
| |
| public double getRealZoomFactor() { |
| if (realZoomFactor == 0.0) { |
| return getZoomFactor(); |
| } else { |
| return realZoomFactor; |
| } |
| } |
| |
| public JScrollPane getScrollPane() { |
| return scrollPane; |
| } |
| |
| public boolean isAllVisible() { |
| return getModel().getHiddenNodes().size() == 0; |
| } |
| |
| public Action createGotoAction(final Figure f) { |
| final DiagramScene diagramScene = this; |
| Action a = new AbstractAction() { |
| |
| public void actionPerformed(ActionEvent e) { |
| diagramScene.gotoFigure(f); |
| } |
| }; |
| |
| a.setEnabled(true); |
| a.putValue(Action.SMALL_ICON, new ColorIcon(f.getColor())); |
| String name = f.getLines()[0]; |
| |
| name += " ("; |
| |
| if (f.getCluster() != null) { |
| name += "B" + f.getCluster().toString(); |
| } |
| if (!this.getFigureWidget(f).isVisible()) { |
| if (f.getCluster() != null) { |
| name += ", "; |
| } |
| name += "hidden"; |
| } |
| name += ")"; |
| a.putValue(Action.NAME, name); |
| return a; |
| } |
| |
| public void setNewModel(DiagramViewModel model) { |
| if (this.model != null) { |
| this.model.getDiagramChangedEvent().removeListener(this); |
| this.model.getViewPropertiesChangedEvent().removeListener(this); |
| } |
| this.model = model; |
| |
| if (this.model == null) { |
| this.modelCopy = null; |
| } else { |
| this.modelCopy = this.model.copy(); |
| } |
| |
| model.getDiagramChangedEvent().addListener(this); |
| model.getViewPropertiesChangedEvent().addListener(this); |
| |
| update(); |
| } |
| |
| private void update() { |
| |
| /*if (startLabel != null) { |
| // Animate fade-out |
| final LabelWidget labelWidget = this.startLabel; |
| labelWidget.setVisible(true); |
| RequestProcessor.getDefault().post(new Runnable() { |
| public void run() { |
| final int Sleep = 200; |
| final int Progress = 10; |
| for (int i = 0; i < 255 / Progress + 1; i++) { |
| try { |
| SwingUtilities.invokeAndWait(new Runnable() { |
| public void run() { |
| Color c = labelWidget.getForeground(); |
| int v = c.getRed(); |
| v += Progress; |
| if (v > 255) { |
| v = 255; |
| } |
| labelWidget.setForeground(new Color(v, v, v, 255 - v)); |
| labelWidget.getScene().validate(); |
| } |
| }); |
| } catch (InterruptedException ex) { |
| } catch (InvocationTargetException ex) { |
| } |
| try { |
| Thread.sleep(Sleep); |
| } catch (InterruptedException ex) { |
| } |
| } |
| labelWidget.setVisible(false); |
| DiagramScene.this.scrollChangeListener.unregister(labelWidget); |
| } |
| }, 1000); |
| startLabel = null; |
| }*/ |
| |
| slotLayer.removeChildren(); |
| mainLayer.removeChildren(); |
| blockLayer.removeChildren(); |
| |
| blockWidgets.clear(); |
| figureWidgets = new HashMap<Figure, FigureWidget>(); |
| slotWidgets = new HashMap<Slot, SlotWidget>(); |
| connectionWidgets = new HashMap<Connection, ConnectionWidget>(); |
| |
| WidgetAction selectAction = new ExtendedSelectAction(selectProvider); |
| Diagram d = getModel().getDiagramToView(); |
| |
| if (getModel().getShowBlocks()) { |
| Scheduler s = Lookup.getDefault().lookup(Scheduler.class); |
| Collection<InputBlock> newBlocks = new ArrayList<InputBlock>(s.schedule(d.getGraph())); |
| d.schedule(newBlocks); |
| } |
| |
| for (Figure f : d.getFigures()) { |
| FigureWidget w = new FigureWidget(f, this, mainLayer); |
| w.getActions().addAction(selectAction); |
| w.getActions().addAction(hoverAction); |
| w.getActions().addAction(ActionFactory.createPopupMenuAction(w)); |
| w.getActions().addAction(new DoubleClickAction(w)); |
| w.setVisible(false); |
| |
| figureWidgets.put(f, w); |
| |
| for (InputSlot s : f.getInputSlots()) { |
| SlotWidget sw = new InputSlotWidget(s, this, slotLayer, w); |
| slotWidgets.put(s, sw); |
| sw.getActions().addAction(selectAction); |
| } |
| |
| for (OutputSlot s : f.getOutputSlots()) { |
| SlotWidget sw = new OutputSlotWidget(s, this, slotLayer, w); |
| slotWidgets.put(s, sw); |
| sw.getActions().addAction(selectAction); |
| } |
| } |
| |
| if (getModel().getShowBlocks()) { |
| for (InputBlock bn : d.getGraph().getBlocks()) { |
| BlockWidget w = new BlockWidget(this, d, bn); |
| w.setVisible(false); |
| blockWidgets.put(bn, w); |
| blockLayer.addChild(w); |
| } |
| } |
| |
| this.smallUpdate(true); |
| |
| } |
| |
| private void smallUpdate(boolean relayout) { |
| |
| this.updateHiddenNodes(model.getHiddenNodes(), relayout); |
| boolean b = this.getUndoRedoEnabled(); |
| this.setUndoRedoEnabled(false); |
| this.setSelection(getModel().getSelectedNodes()); |
| this.setUndoRedoEnabled(b); |
| this.validate(); |
| } |
| |
| private boolean isVisible(Connection c) { |
| FigureWidget w1 = figureWidgets.get(c.getInputSlot().getFigure()); |
| FigureWidget w2 = figureWidgets.get(c.getOutputSlot().getFigure()); |
| |
| if (w1.isVisible() && w2.isVisible()) { |
| return true; |
| } |
| |
| return false; |
| } |
| |
| private void relayout(Set<Widget> oldVisibleWidgets) { |
| |
| Diagram diagram = getModel().getDiagramToView(); |
| |
| HashSet<Figure> figures = new HashSet<Figure>(); |
| |
| for (Figure f : diagram.getFigures()) { |
| FigureWidget w = figureWidgets.get(f); |
| if (w.isVisible()) { |
| figures.add(f); |
| } |
| } |
| |
| HashSet<Connection> edges = new HashSet<Connection>(); |
| |
| for (Connection c : diagram.getConnections()) { |
| if (isVisible(c)) { |
| edges.add(c); |
| } |
| } |
| |
| if (getModel().getShowBlocks()) { |
| HierarchicalClusterLayoutManager m = new HierarchicalClusterLayoutManager(OldHierarchicalLayoutManager.Combine.SAME_OUTPUTS); |
| HierarchicalLayoutManager manager = new HierarchicalLayoutManager(HierarchicalLayoutManager.Combine.SAME_OUTPUTS); |
| manager.setMaxLayerLength(9); |
| manager.setMinLayerDifference(3); |
| m.setManager(manager); |
| m.setSubManager(new HierarchicalLayoutManager(HierarchicalLayoutManager.Combine.SAME_OUTPUTS)); |
| m.doLayout(new LayoutGraph(edges, figures)); |
| |
| } else { |
| HierarchicalLayoutManager manager = new HierarchicalLayoutManager(HierarchicalLayoutManager.Combine.SAME_OUTPUTS); |
| manager.setMaxLayerLength(10); |
| manager.doLayout(new LayoutGraph(edges, figures)); |
| } |
| |
| int maxX = -BORDER_SIZE; |
| int maxY = -BORDER_SIZE; |
| for (Figure f : diagram.getFigures()) { |
| FigureWidget w = figureWidgets.get(f); |
| if (w.isVisible()) { |
| Point p = f.getPosition(); |
| Dimension d = f.getSize(); |
| maxX = Math.max(maxX, p.x + d.width); |
| maxY = Math.max(maxY, p.y + d.height); |
| } |
| } |
| |
| for (Connection c : diagram.getConnections()) { |
| List<Point> points = c.getControlPoints(); |
| FigureWidget w1 = figureWidgets.get((Figure) c.getTo().getVertex()); |
| FigureWidget w2 = figureWidgets.get((Figure) c.getFrom().getVertex()); |
| if (w1.isVisible() && w2.isVisible()) { |
| for (Point p : points) { |
| if (p != null) { |
| maxX = Math.max(maxX, p.x); |
| maxY = Math.max(maxY, p.y); |
| } |
| } |
| } |
| } |
| |
| if (getModel().getShowBlocks()) { |
| for (Block b : diagram.getBlocks()) { |
| BlockWidget w = blockWidgets.get(b.getInputBlock()); |
| if (w != null && w.isVisible()) { |
| Rectangle r = b.getBounds(); |
| maxX = Math.max(maxX, r.x + r.width); |
| maxY = Math.max(maxY, r.y + r.height); |
| } |
| } |
| } |
| |
| bottomRight.setPreferredLocation(new Point(maxX + BORDER_SIZE, maxY + BORDER_SIZE)); |
| int offx = 0; |
| int offy = 0; |
| int curWidth = maxX + 2 * BORDER_SIZE; |
| int curHeight = maxY + 2 * BORDER_SIZE; |
| |
| Rectangle bounds = this.getScrollPane().getBounds(); |
| if (curWidth < bounds.width) { |
| offx = (bounds.width - curWidth) / 2; |
| } |
| |
| if (curHeight < bounds.height) { |
| offy = (bounds.height - curHeight) / 2; |
| } |
| |
| final int offx2 = offx; |
| final int offy2 = offy; |
| |
| SceneAnimator animator = this.getSceneAnimator(); |
| connectionLayer.removeChildren(); |
| int visibleFigureCount = 0; |
| for (Figure f : diagram.getFigures()) { |
| if (figureWidgets.get(f).isVisible()) { |
| visibleFigureCount++; |
| } |
| } |
| |
| for (Figure f : diagram.getFigures()) { |
| for (OutputSlot s : f.getOutputSlots()) { |
| SceneAnimator anim = animator; |
| if (visibleFigureCount > ANIMATION_LIMIT) { |
| anim = null; |
| } |
| processOutputSlot(s, s.getConnections(), 0, null, null, offx2, offy2, anim); |
| } |
| } |
| |
| for (Figure f : diagram.getFigures()) { |
| FigureWidget w = figureWidgets.get(f); |
| if (w.isVisible()) { |
| Point p = f.getPosition(); |
| Point p2 = new Point(p.x + offx2, p.y + offy2); |
| Rectangle r = new Rectangle(p.x + offx2, p.y + offy2, f.getSize().width, f.getSize().height); |
| if (oldVisibleWidgets.contains(w)) { |
| if (visibleFigureCount > ANIMATION_LIMIT) { |
| w.setPreferredLocation(p2); |
| } else { |
| animator.animatePreferredLocation(w, p2); |
| } |
| } else { |
| w.setPreferredLocation(p2); |
| } |
| } |
| } |
| |
| if (getModel().getShowBlocks()) { |
| for (Block b : diagram.getBlocks()) { |
| BlockWidget w = blockWidgets.get(b.getInputBlock()); |
| if (w != null && w.isVisible()) { |
| Point location = new Point(b.getBounds().x + offx2, b.getBounds().y + offy2); |
| Rectangle r = new Rectangle(location.x, location.y, b.getBounds().width, b.getBounds().height); |
| if (oldVisibleWidgets.contains(w)) { |
| if (visibleFigureCount > ANIMATION_LIMIT) { |
| w.setPreferredBounds(r); |
| } else { |
| animator.animatePreferredBounds(w, r); |
| } |
| } else { |
| w.setPreferredBounds(r); |
| } |
| } |
| } |
| } |
| } |
| private final Point specialNullPoint = new Point(Integer.MAX_VALUE, Integer.MAX_VALUE); |
| |
| private void processOutputSlot(OutputSlot s, List<Connection> connections, int controlPointIndex, Point lastPoint, LineWidget predecessor, int offx, int offy, SceneAnimator animator) { |
| Map<Point, List<Connection>> pointMap = new HashMap<Point, List<Connection>>(); |
| |
| for (Connection c : connections) { |
| |
| if (!isVisible(c)) { |
| continue; |
| } |
| |
| List<Point> controlPoints = c.getControlPoints(); |
| if (controlPointIndex >= controlPoints.size()) { |
| continue; |
| } |
| |
| Point cur = controlPoints.get(controlPointIndex); |
| if (cur == null) { |
| cur = specialNullPoint; |
| } else if (controlPointIndex == 0 && !s.getShowName()) { |
| cur = new Point(cur.x, cur.y - SLOT_OFFSET); |
| } else if (controlPointIndex == controlPoints.size() - 1 && !c.getInputSlot().getShowName()) { |
| cur = new Point(cur.x, cur.y + SLOT_OFFSET); |
| } |
| |
| if (pointMap.containsKey(cur)) { |
| pointMap.get(cur).add(c); |
| } else { |
| List<Connection> newList = new ArrayList<Connection>(2); |
| newList.add(c); |
| pointMap.put(cur, newList); |
| } |
| |
| } |
| |
| for (Point p : pointMap.keySet()) { |
| List<Connection> connectionList = pointMap.get(p); |
| |
| boolean isBold = false; |
| boolean isDashed = true; |
| |
| for (Connection c : connectionList) { |
| |
| if (c.getStyle() == Connection.ConnectionStyle.BOLD) { |
| isBold = true; |
| } |
| |
| if (c.getStyle() != Connection.ConnectionStyle.DASHED) { |
| isDashed = false; |
| } |
| } |
| |
| LineWidget newPredecessor = predecessor; |
| if (p == specialNullPoint) { |
| |
| } else if (lastPoint == specialNullPoint) { |
| |
| } else if (lastPoint != null) { |
| Point p1 = new Point(lastPoint.x + offx, lastPoint.y + offy); |
| Point p2 = new Point(p.x + offx, p.y + offy); |
| LineWidget w = new LineWidget(this, s, connectionList, p1, p2, predecessor, animator, isBold, isDashed); |
| newPredecessor = w; |
| connectionLayer.addChild(w); |
| w.getActions().addAction(hoverAction); |
| } |
| |
| processOutputSlot(s, connectionList, controlPointIndex + 1, p, newPredecessor, offx, offy, animator); |
| } |
| } |
| |
| private void clearSelection() { |
| if (selectedWidgets.size() == 0) { |
| return; |
| } |
| for (FigureWidget w : selectedWidgets) { |
| assert w.getState().isSelected(); |
| w.setState(w.getState().deriveSelected(false)); |
| content.remove(w.getNode()); |
| } |
| selectedWidgets.clear(); |
| } |
| |
| public Lookup getLookup() { |
| return lookup; |
| } |
| |
| public void gotoFigures(final List<Figure> figures) { |
| Rectangle overall = null; |
| showFigures(figures); |
| for (Figure f : figures) { |
| |
| FigureWidget fw = getFigureWidget(f); |
| if (fw != null) { |
| Rectangle r = fw.getBounds(); |
| Point p = fw.getLocation(); |
| Rectangle r2 = new Rectangle(p.x, p.y, r.width, r.height); |
| |
| if (overall == null) { |
| overall = r2; |
| } else { |
| overall = overall.union(r2); |
| } |
| } |
| } |
| if (overall != null) { |
| centerRectangle(overall); |
| } |
| } |
| |
| private Point calcCenter(Rectangle r) { |
| |
| Point center = new Point((int) r.getCenterX(), (int) r.getCenterY()); |
| center.x -= getScrollPane().getViewport().getViewRect().width / 2; |
| center.y -= getScrollPane().getViewport().getViewRect().height / 2; |
| |
| // Ensure to be within area |
| center.x = Math.max(0, center.x); |
| center.x = Math.min(getScrollPane().getViewport().getViewSize().width - getScrollPane().getViewport().getViewRect().width, center.x); |
| center.y = Math.max(0, center.y); |
| center.y = Math.min(getScrollPane().getViewport().getViewSize().height - getScrollPane().getViewport().getViewRect().height, center.y); |
| |
| return center; |
| } |
| |
| private void centerRectangle(Rectangle r) { |
| |
| if (getScrollPane().getViewport().getViewRect().width == 0 || getScrollPane().getViewport().getViewRect().height == 0) { |
| return; |
| } |
| |
| Rectangle r2 = new Rectangle(r.x, r.y, r.width, r.height); |
| r2 = convertSceneToView(r2); |
| |
| double factorX = (double) r2.width / (double) getScrollPane().getViewport().getViewRect().width; |
| double factorY = (double) r2.height / (double) getScrollPane().getViewport().getViewRect().height; |
| double factor = Math.max(factorX, factorY); |
| if (factor >= 1.0) { |
| Point p = getScrollPane().getViewport().getViewPosition(); |
| setZoomFactor(getZoomFactor() / factor); |
| r2.x /= factor; |
| r2.y /= factor; |
| r2.width /= factor; |
| r2.height /= factor; |
| getScrollPane().getViewport().setViewPosition(calcCenter(r2)); |
| } else { |
| getScrollPane().getViewport().setViewPosition(calcCenter(r2)); |
| } |
| } |
| |
| private void addToSelection(Figure f) { |
| FigureWidget w = getFigureWidget(f); |
| addToSelection(w); |
| } |
| |
| private void addToSelection(FigureWidget w) { |
| assert !selectedWidgets.contains(w); |
| selectedWidgets.add(w); |
| content.add(w.getNode()); |
| w.setState(w.getState().deriveSelected(true)); |
| } |
| |
| private void setSelection(Set<Integer> nodes) { |
| clearSelection(); |
| for (Figure f : getModel().getDiagramToView().getFigures()) { |
| if (doesIntersect(f.getSource().getSourceNodesAsSet(), nodes)) { |
| addToSelection(f); |
| } |
| } |
| selectionUpdated(); |
| this.validate(); |
| } |
| |
| public void setSelection(Collection<Figure> list) { |
| clearSelection(); |
| for (Figure f : list) { |
| addToSelection(f); |
| } |
| |
| selectionUpdated(); |
| this.validate(); |
| } |
| |
| public Set<Figure> getSelectedFigures() { |
| Set<Figure> result = new HashSet<Figure>(); |
| for (Widget w : selectedWidgets) { |
| if (w instanceof FigureWidget) { |
| FigureWidget fw = (FigureWidget) w; |
| if (fw.getState().isSelected()) { |
| result.add(fw.getFigure()); |
| } |
| } |
| } |
| return result; |
| } |
| |
| public Set<Integer> getSelectedNodes() { |
| Set<Integer> result = new HashSet<Integer>(); |
| for (Widget w : selectedWidgets) { |
| if (w instanceof FigureWidget) { |
| FigureWidget fw = (FigureWidget) w; |
| if (fw.getState().isSelected()) { |
| result.addAll(fw.getFigure().getSource().getSourceNodesAsSet()); |
| } |
| } |
| } |
| return result; |
| } |
| |
| private UndoRedo.Manager getUndoRedoManager() { |
| if (undoRedoManager == null) { |
| undoRedoManager = new UndoRedo.Manager(); |
| undoRedoManager.setLimit(UNDOREDO_LIMIT); |
| } |
| |
| return undoRedoManager; |
| } |
| |
| public UndoRedo getUndoRedo() { |
| return getUndoRedoManager(); |
| } |
| |
| private boolean isVisible(Figure f) { |
| for (Integer n : f.getSource().getSourceNodesAsSet()) { |
| if (getModel().getHiddenNodes().contains(n)) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| private boolean doesIntersect(Set s1, Set s2) { |
| if (s1.size() > s2.size()) { |
| Set tmp = s1; |
| s1 = s2; |
| s2 = tmp; |
| } |
| |
| for (Object o : s1) { |
| if (s2.contains(o)) { |
| return true; |
| } |
| } |
| |
| return false; |
| } |
| |
| public void showNot(final Set<Integer> nodes) { |
| updateHiddenNodes(nodes, true); |
| } |
| |
| public void showOnly(final Set<Integer> nodes) { |
| HashSet<Integer> allNodes = new HashSet<Integer>(getModel().getGraphToView().getGroup().getAllNodes()); |
| allNodes.removeAll(nodes); |
| updateHiddenNodes(allNodes, true); |
| } |
| |
| private void updateHiddenNodes(Set<Integer> newHiddenNodes, boolean doRelayout) { |
| |
| Set<InputBlock> visibleBlocks = new HashSet<InputBlock>(); |
| |
| Diagram diagram = getModel().getDiagramToView(); |
| assert diagram != null; |
| |
| Set<Widget> oldVisibleWidgets = new HashSet<Widget>(); |
| |
| for (Figure f : diagram.getFigures()) { |
| FigureWidget w = figureWidgets.get(f); |
| if (w.isVisible()) { |
| oldVisibleWidgets.add(w); |
| } |
| } |
| |
| if (getModel().getShowBlocks()) { |
| for (InputBlock b : diagram.getGraph().getBlocks()) { |
| BlockWidget w = blockWidgets.get(b); |
| if (w.isVisible()) { |
| oldVisibleWidgets.add(w); |
| } |
| } |
| } |
| |
| for (Figure f : diagram.getFigures()) { |
| boolean hiddenAfter = doesIntersect(f.getSource().getSourceNodesAsSet(), newHiddenNodes); |
| |
| FigureWidget w = this.figureWidgets.get(f); |
| w.setBoundary(false); |
| if (!hiddenAfter) { |
| // Figure is shown |
| w.setVisible(true); |
| for (InputNode n : f.getSource().getSourceNodes()) { |
| visibleBlocks.add(diagram.getGraph().getBlock(n)); |
| } |
| } else { |
| // Figure is hidden |
| w.setVisible(false); |
| } |
| } |
| |
| if (getModel().getShowNodeHull()) { |
| List<FigureWidget> boundaries = new ArrayList<FigureWidget>(); |
| for (Figure f : diagram.getFigures()) { |
| FigureWidget w = this.figureWidgets.get(f); |
| if (!w.isVisible()) { |
| Set<Figure> set = new HashSet<Figure>(f.getPredecessorSet()); |
| set.addAll(f.getSuccessorSet()); |
| |
| boolean b = false; |
| for (Figure neighbor : set) { |
| FigureWidget neighborWidget = figureWidgets.get(neighbor); |
| if (neighborWidget.isVisible()) { |
| b = true; |
| break; |
| } |
| } |
| |
| if (b) { |
| w.setBoundary(true); |
| for (InputNode n : f.getSource().getSourceNodes()) { |
| visibleBlocks.add(diagram.getGraph().getBlock(n)); |
| } |
| boundaries.add(w); |
| } |
| } |
| } |
| |
| for (FigureWidget w : boundaries) { |
| if (w.isBoundary()) { |
| w.setVisible(true); |
| } |
| } |
| } |
| |
| if (getModel().getShowBlocks()) { |
| for (InputBlock b : diagram.getGraph().getBlocks()) { |
| |
| boolean visibleAfter = visibleBlocks.contains(b); |
| |
| BlockWidget w = blockWidgets.get(b); |
| if (visibleAfter) { |
| // Block must be shown |
| w.setVisible(true); |
| } else { |
| // Block must be hidden |
| w.setVisible(false); |
| } |
| } |
| } |
| |
| getModel().setHiddenNodes(newHiddenNodes); |
| if (doRelayout) { |
| relayout(oldVisibleWidgets); |
| } |
| this.validate(); |
| addUndo(); |
| } |
| |
| private void showFigures(Collection<Figure> f) { |
| HashSet<Integer> newHiddenNodes = new HashSet<Integer>(getModel().getHiddenNodes()); |
| for (Figure fig : f) { |
| newHiddenNodes.removeAll(fig.getSource().getSourceNodesAsSet()); |
| } |
| updateHiddenNodes(newHiddenNodes, true); |
| } |
| |
| private void showFigure(Figure f) { |
| HashSet<Integer> newHiddenNodes = new HashSet<Integer>(getModel().getHiddenNodes()); |
| newHiddenNodes.removeAll(f.getSource().getSourceNodesAsSet()); |
| updateHiddenNodes(newHiddenNodes, true); |
| } |
| |
| public void showAll(final Collection<Figure> f) { |
| showFigures(f); |
| |
| } |
| |
| public void show(final Figure f) { |
| showFigure(f); |
| } |
| |
| public void gotoFigure(final Figure f) { |
| |
| if (!isVisible(f)) { |
| showFigure(f); |
| } |
| |
| FigureWidget fw = getFigureWidget(f); |
| if (fw != null) { |
| Rectangle r = fw.getBounds(); |
| Point p = fw.getLocation(); |
| centerRectangle(new Rectangle(p.x, p.y, r.width, r.height)); |
| |
| // Select figure |
| clearSelection(); |
| addToSelection(fw); |
| selectionUpdated(); |
| } |
| } |
| |
| public JPopupMenu createPopupMenu() { |
| JPopupMenu menu = new JPopupMenu(); |
| for (Action a : actions) { |
| if (a == null) { |
| menu.addSeparator(); |
| } else { |
| menu.add(a); |
| } |
| } |
| return menu; |
| } |
| |
| private static class DiagramUndoRedo extends AbstractUndoableEdit implements ChangedListener<DiagramViewModel> { |
| |
| private DiagramViewModel oldModel; |
| private DiagramViewModel newModel; |
| private Point oldScrollPosition; |
| private DiagramScene scene; |
| |
| public DiagramUndoRedo(DiagramScene scene, Point oldScrollPosition, DiagramViewModel oldModel, DiagramViewModel newModel) { |
| assert oldModel != null; |
| assert newModel != null; |
| this.oldModel = oldModel; |
| this.newModel = newModel; |
| this.scene = scene; |
| this.oldScrollPosition = oldScrollPosition; |
| } |
| |
| @Override |
| public void redo() throws CannotRedoException { |
| super.redo(); |
| boolean b = scene.getUndoRedoEnabled(); |
| scene.setUndoRedoEnabled(false); |
| scene.getModel().getViewChangedEvent().addListener(this); |
| scene.getModel().setData(newModel); |
| scene.getModel().getViewChangedEvent().removeListener(this); |
| scene.setUndoRedoEnabled(b); |
| } |
| |
| @Override |
| public void undo() throws CannotUndoException { |
| super.undo(); |
| boolean b = scene.getUndoRedoEnabled(); |
| scene.setUndoRedoEnabled(false); |
| scene.getModel().getViewChangedEvent().addListener(this); |
| scene.getModel().setData(oldModel); |
| scene.getModel().getViewChangedEvent().removeListener(this); |
| |
| SwingUtilities.invokeLater(new Runnable() { |
| |
| public void run() { |
| scene.setScrollPosition(oldScrollPosition); |
| } |
| }); |
| |
| scene.setUndoRedoEnabled(b); |
| } |
| |
| public void changed(DiagramViewModel source) { |
| scene.getModel().getViewChangedEvent().removeListener(this); |
| if (oldModel.getSelectedNodes().equals(newModel.getHiddenNodes())) { |
| scene.smallUpdate(false); |
| } else { |
| scene.smallUpdate(true); |
| } |
| } |
| } |
| private boolean undoRedoEnabled = true; |
| |
| public void setUndoRedoEnabled(boolean b) { |
| this.undoRedoEnabled = b; |
| } |
| |
| public boolean getUndoRedoEnabled() { |
| return undoRedoEnabled; |
| } |
| |
| public void changed(DiagramViewModel source) { |
| assert source == model : "Receive only changed event from current model!"; |
| assert source != null; |
| update(); |
| } |
| |
| private void addUndo() { |
| |
| DiagramViewModel newModelCopy = model.copy(); |
| |
| if (undoRedoEnabled) { |
| this.getUndoRedoManager().undoableEditHappened(new UndoableEditEvent(this, new DiagramUndoRedo(this, this.getScrollPosition(), modelCopy, newModelCopy))); |
| } |
| |
| this.modelCopy = newModelCopy; |
| } |
| } |
