myjung2testview.java

软件测试工具包 Java源代码 软件测试工具包 Java源代码

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;
        }
        
    }
	
	
}