package myJung2Test.views;import javax.swing.*;import java.awt.BorderLayout; import java.awt.Frame; import java.awt.GridLayout; import java.awt.Panel; import java.awt.Dimension; import java.awt.Color; import java.awt.event.*;import java.awt.*;import java.util.Collection;import java.util.HashSet;import java.util.Map;import java.util.Set;import java.util.HashMap;import org.eclipse.swt.widgets.Composite;import org.eclipse.ui.part.*;import org.eclipse.jface.viewers.*;import org.eclipse.swt.graphics.Image;import org.eclipse.jface.action.*;import org.eclipse.jface.dialogs.MessageDialog;import org.eclipse.ui.*;import org.eclipse.swt.widgets.Menu;import org.eclipse.swt.SWT;import org.eclipse.swt.awt.SWT_AWT; import edu.uci.ics.jung.graph.Graph;import edu.uci.ics.jung.graph.DirectedSparseMultigraph;import edu.uci.ics.jung.graph.util.EdgeType;import edu.uci.ics.jung.algorithms.layout.*;import edu.uci.ics.jung.visualization.VisualizationViewer;import edu.uci.ics.jung.visualization.GraphZoomScrollPane;import edu.uci.ics.jung.visualization.picking.MultiPickedState;import edu.uci.ics.jung.visualization.decorators.PickableVertexPaintTransformer; import edu.uci.ics.jung.visualization.decorators.PickableEdgePaintTransformer;import edu.uci.ics.jung.visualization.decorators.*;import edu.uci.ics.jung.visualization.renderers.Renderer;import edu.uci.ics.jung.visualization.transform.*;import edu.uci.ics.jung.visualization.control.*;import edu.uci.ics.jung.visualization.RenderContext;import edu.uci.ics.jung.visualization.GraphZoomScrollPane;import org.apache.commons.collections15.*;/** * This sample class demonstrates how to plug-in a new * workbench view. The view shows data obtained from the * model. The sample creates a dummy model on the fly, * but a real implementation would connect to the model * available either in this or another plug-in (e.g. the workspace). * The view is connected to the model using a content provider. * <p> * The view uses a label provider to define how model * objects should be presented in the view. Each * view can present the same model objects using * different labels and icons, if needed. Alternatively, * a single label provider can be shared between views * in order to ensure that objects of the same type are * presented in the same way everywhere. * <p> */public class myJung2TestView extends ViewPart {	static int edgeCount=0;	VisualizationViewer<MyNode, MyLink> vv;    protected Map<MyLink,Number> edge_weight;     protected EdgeWeightStrokeFunction<MyLink> ewcs;    	/*	 * The content provider class is responsible for	 * providing objects to the view. It can wrap	 * existing objects in adapters or simply return	 * objects as-is. These objects may be sensitive	 * to the current input of the view, or ignore	 * it and always show the same content 	 * (like Task List, for example).	 */		/**	 * The constructor.	 */	public myJung2TestView() {		edge_weight = new HashMap<MyLink,Number>();	}	/**	 * This is a callback that will allow us	 * to create the viewer and initialize it.	 */	public void createPartControl(Composite parent) {		DirectedSparseMultigraph<MyNode, MyLink>g =CreateGraph();		Layout<MyNode, MyLink> layout = new CircleLayout(g);		layout.setSize(new Dimension(300,300)); // sets the initial size of the space//		 The BasicVisualizationServer<V,E> is parameterized by the edge types		vv =new VisualizationViewer<MyNode, MyLink>(layout);		vv.setPreferredSize(new Dimension(350,350)); //Sets the viewing area size*/		//			 Setup up a new vertex to paint transformer...		Transformer<MyNode,Paint> vertexPaint = new Transformer<MyNode,Paint>() {			public Paint transform(MyNode i) {				return Color.GREEN;			}		};								float dash[] = {10.0f};		final Stroke edgeStroke = new BasicStroke(1.0f, BasicStroke.CAP_BUTT,		BasicStroke.JOIN_MITER, 10.0f, dash, 0.0f);		Transformer<MyLink, Stroke> edgeStrokeTransformer =		new Transformer<MyLink, Stroke>() {			public Stroke transform(MyLink s) {					return edgeStroke;			}		};		ewcs =             new EdgeWeightStrokeFunction<MyLink>(edge_weight);        		vv.getRenderContext().setVertexFillPaintTransformer(vertexPaint);		vv.getRenderContext().setEdgeStrokeTransformer(edgeStrokeTransformer);		vv.getRenderContext().setEdgeStrokeTransformer(ewcs);		vv.getRenderContext().setVertexLabelTransformer(new ToStringLabeller());		vv.getRenderContext().setEdgeLabelTransformer(new ToStringLabeller());		vv.getRenderer().getVertexLabelRenderer().setPosition(Renderer.VertexLabel.Position.CNTR);		vv.getRenderContext().setVertexFillPaintTransformer(new PickableVertexPaintTransformer(vv.getPickedVertexState(), Color.red, Color.yellow));		vv.getRenderContext().setEdgeDrawPaintTransformer(new PickableEdgePaintTransformer(vv.getPickedVertexState(), Color.red, Color.yellow));		ewcs.setWeighted(true);		DefaultModalGraphMouse gm = new DefaultModalGraphMouse();		gm.setMode(ModalGraphMouse.Mode.PICKING);				vv.setGraphMouse(gm);		vv.getPickedVertexState().addItemListener(new ItemListener() {				public void itemStateChanged(ItemEvent e) {				if(e.getStateChange() == ItemEvent.SELECTED) {			    	Collection Vpicked = vv.getPickedVertexState().getPicked();		            for(Object v : Vpicked) {		               String tt=v.toString() ;		               System.out.println(tt);				    }				} else {				}			}});				vv.getPickedEdgeState().addItemListener(new ItemListener() {				public void itemStateChanged(ItemEvent e) {				if(e.getStateChange() == ItemEvent.SELECTED) {			    	Collection Epicked = vv.getPickedEdgeState().getPicked();		            for(Object ve : Epicked) {		               String tt=ve.toString() ;		               System.out.println(tt);				    }				} else {				}			}});				Composite composite = new Composite(parent, SWT.NO_BACKGROUND | SWT.EMBEDDED);		Frame frame = SWT_AWT.new_Frame(composite);		JPanel jp = new JPanel();        jp.setLayout(new BorderLayout());//        final GraphZoomScrollPane scrollPane = new GraphZoomScrollPane(vv);//        jp.add(scrollPane);//        jp.add(vv);        vv.setBackground(Color.white);//        frame.add(jp);                JRootPane root = new JRootPane(); 		frame.add(vv); 		vv.add(root); 		gm.setZoomAtMouse(true);	}		    protected DirectedSparseMultigraph CreateGraph(){    	DirectedSparseMultigraph<MyNode, MyLink> g = new DirectedSparseMultigraph<MyNode, MyLink>();//    	 Add some vertices. From above we defined these to be type Integer.//    	 Create some MyNode objects to use as vertices    	MyNode n2,n3,n4,n5;    	MyNode n1 = new MyNode(1);     	n2 = new MyNode(2);     	n3 = new MyNode(3);    	n4 = new MyNode(4);     	n5 = new MyNode(5); // note n1-n5 declared elsewhere.//    	 Add some directed edges along with the vertices to the graph    	g.addEdge(new MyLink(2.0, 48),n1, n2, EdgeType.DIRECTED); // This method    	g.addEdge(new MyLink(2.0, 48),n2, n3, EdgeType.DIRECTED);    	g.addEdge(new MyLink(3.0, 192), n3, n5, EdgeType.DIRECTED);    	g.addEdge(new MyLink(2.0, 48), n5, n4, EdgeType.DIRECTED); // or we can use    	g.addEdge(new MyLink(2.0, 48), n4, n2); // In a directed graph the    	g.addEdge(new MyLink(2.0, 48), n3, n1); // first node is the source    	g.addEdge(new MyLink(10.0, 48), n2, n5);// and the second the destination    	Collection<MyLink> myedges=g.getEdges();    	    	for(MyLink ml:myedges){    		edge_weight.put(ml,ml.getWeight());    	}    	return g;    }		private void showMessage(String message) {		MessageDialog.openInformation(			null,			"myJung2Test View",			message);	}	/**	 * Passing the focus request to the viewer's control.	 */	public void setFocus() {		}		private final static class EdgeWeightStrokeFunction<E>    implements Transformer<E,Stroke>    {        protected static final Stroke basic = new BasicStroke(1);        protected static final Stroke heavy = new BasicStroke(2);        protected static Stroke MyWeightStk;        protected static final Stroke dotted = RenderContext.DOTTED;        protected double wei=1;                protected boolean weighted = false;        protected Map<E,Number> edge_weight;                public EdgeWeightStrokeFunction(Map<E,Number> edge_weight)        {            this.edge_weight = edge_weight;        }                public void setWeighted(boolean weighted)        {            this.weighted = weighted;        }                public Stroke transform(E e)        { /*           if (weighted)            {                if (drawHeavy(e))                    return heavy;                else                    return dotted;            }            else                return basic;*/        	 if (weighted)            {                if (drawHeavy(e)){                	MyWeightStk=new BasicStroke((int)wei);                    return MyWeightStk;                }                else                    return dotted;            }            else                return basic;      	        }                protected boolean drawHeavy(E e)        {            double value = edge_weight.get(e).doubleValue();            wei=value;            if (value > 2)                return true;            else                return false;        }            }		}