import org.cytoscape.view.model.View; //导入依赖的package包/类
public static CoordinateData forNodes(CyNetworkView networkView, Collection<CyNode> nodes) {
	double xmin = 100000000;
	double xmax = -100000000;
	double ymin = 100000000;
	double ymax = -100000000;
	
	Map<CyNode,double[]> coordinates = new HashMap<>();
	Map<CyNode,Double> radii = new HashMap<>();
	
	for(CyNode node : nodes) {
		View<CyNode> nodeView = networkView.getNodeView(node);
		if(nodeView != null) {
			double x = nodeView.getVisualProperty(BasicVisualLexicon.NODE_X_LOCATION);
			double y = nodeView.getVisualProperty(BasicVisualLexicon.NODE_Y_LOCATION);
			double radius = nodeView.getVisualProperty(BasicVisualLexicon.NODE_WIDTH);
			
			coordinates.put(node, new double[]{x,y});
			radii.put(node, radius);
			
			xmin = Double.min(xmin, x);
			xmax = Double.max(xmax, x);
			ymin = Double.min(ymin, y);
			ymax = Double.max(ymax, y);
		}
	}
	
	return new CoordinateData(xmin, xmax, ymin, ymax, coordinates, radii);
}
 

import org.cytoscape.view.model.View; //导入依赖的package包/类
@Override
public TaskIterator createTaskIterator() {
	TaskIterator tasks = new TaskIterator();
	
	CyLayoutAlgorithm attributeCircle = layoutManager.getLayout("attributes-layout");
	TaskIterator attributeLayoutTasks = attributeCircle.createTaskIterator(view, attributeCircle.createLayoutContext(), CyLayoutAlgorithm.ALL_NODE_VIEWS, layoutAttribute);
	tasks.append(attributeLayoutTasks);
	
	CyLayoutAlgorithm force_directed = layoutManager.getLayout("force-directed");
	
	for(Collection<CyNode> cluster : clusters) {
		Set<View<CyNode>> nodeViewSet = new HashSet<>();
		for(CyNode node : cluster) {
			nodeViewSet.add(view.getNodeView(node));
		}
		// Only apply layout to nodes of size greater than 4
		if (nodeViewSet.size() > 4) {
			TaskIterator forceTasks = force_directed.createTaskIterator(view, force_directed.createLayoutContext(), nodeViewSet, null);
			tasks.append(forceTasks);
		}
	}
	
	return tasks;
}
 

import org.cytoscape.view.model.View; //导入依赖的package包/类
private void applyVisualStyle(CyNetworkView originNetworkView, CyNetworkView summaryNetworkView, SummaryNetwork summaryNetwork) {
	VisualStyle vs = visualMappingManager.getVisualStyle(originNetworkView);
	
	for(View<CyNode> nodeView : summaryNetworkView.getNodeViews()) {
		// Label
		String name = summaryNetworkView.getModel().getRow(nodeView.getModel()).get("name", String.class);
		nodeView.setLockedValue(BasicVisualLexicon.NODE_LABEL, name);
		
		// Node size
		CyNode node = nodeView.getModel();
		SummaryCluster cluster = summaryNetwork.getClusterFor(node);
		int numNodes = cluster.getNodes().size();
		nodeView.setLockedValue(BasicVisualLexicon.NODE_SIZE, (double)numNodes);
	}
	
	visualMappingManager.setVisualStyle(vs, summaryNetworkView);
}
 

import org.cytoscape.view.model.View; //导入依赖的package包/类
public static void UpdateNodeNames(CyNetworkView myNetView) {
if (done == 1) {
    return;
}

CyNetwork myNetwork = myNetView.getModel();
DataConnectionRest dataConnection = new DataConnectionRest();

for (View<CyNode> myNode : myNetView.getNodeViews()) {
    int nodeID = Integer.parseInt(myNetwork.getRow(myNode.getModel()).get(CyNetwork.NAME, String.class).replaceAll("\"", ""));
    String userName = dataConnection.getUserNameFromID(nodeID);
    myNode.setVisualProperty(BasicVisualLexicon.NODE_LABEL, userName);
    myNode.setVisualProperty(BasicVisualLexicon.NODE_WIDTH, userName.length() * 7.5);
}
myNetView.updateView();
done = 1;
   }
 

import org.cytoscape.view.model.View; //导入依赖的package包/类
@Override
public void processCallResponse(ExtensionCall call, Object callRetValue) {

	List<Double> values = (List<Double>)callRetValue;

	CyTable defNodeTab = currNet.getDefaultNodeTable();
	CyNetworkView networkView = getPlugin().getCyNetViewMgr().getNetworkViews(currNet).iterator().next();

	for(int i = 0; i < (values.size() / 3); ++i){
		Long neoid = values.get(i*3).longValue();
		Double x = values.get(i*3+1);
		Double y = values.get(i*3+2);

		Set<CyNode> nodeSet = CyUtils.getNodesWithValue(currNet, defNodeTab, "neoid", neoid);
		CyNode n = nodeSet.iterator().next();

		View<CyNode> nodeView = networkView.getNodeView(n);
		nodeView.setVisualProperty(BasicVisualLexicon.NODE_X_LOCATION, x);
		nodeView.setVisualProperty(BasicVisualLexicon.NODE_Y_LOCATION, y);

		CyUtils.updateVisualStyle(getPlugin().getVisualMappingManager(), networkView, currNet);
	}
}
 

import org.cytoscape.view.model.View; //导入依赖的package包/类
private CyNetworkView createNetworkView(SummaryNetwork summaryNetwork) {
	CyNetworkView networkView = networkViewFactory.createNetworkView(summaryNetwork.network);
	for(View<CyNode> nodeView : networkView.getNodeViews()) {
		SummaryCluster cluster = summaryNetwork.getClusterFor(nodeView.getModel());
		Point2D.Double center = cluster.getCoordinateData().getCenter();
		nodeView.setVisualProperty(BasicVisualLexicon.NODE_X_LOCATION, center.x);
		nodeView.setVisualProperty(BasicVisualLexicon.NODE_Y_LOCATION, center.y);
	}
	return networkView;
}
 

import org.cytoscape.view.model.View; //导入依赖的package包/类
/**
 * @desc - Adds nodes to the protein network from the information returned by the Slim* run.
 * @param uniprotIDs - list of all Uniprot IDs input to the returned run.
 * @param nodeIds - map linking all selected Uniprot IDs to their CyNodes, for easy access to the network.
 * @param newNetwork - CyNetwork of the network being altered.
 * @param networkViewManager - NetworkViewManager for the network being altered. Initialised in CyActivator.
 * @param manager - CyApplicationManager for the network being altered. Initialised in CyActivator.
 */
public void addNodes (List<String> uniprotIDs, Map<String, CyNode> nodeIds, CyNetwork newNetwork,
                      CyNetworkViewManager networkViewManager, CyApplicationManager manager) {

    // Add network view
    final Collection<CyNetworkView> views = networkViewManager.getNetworkViews(newNetwork);
    CyNetworkView myView = null;
    if(views.size() != 0) {
        myView = views.iterator().next();
    }

    if (myView == null) {
        // create a new view for my network
        myView = networkViewFactory.createNetworkView(newNetwork);
        networkViewManager.addNetworkView(myView);
    } else {
        System.out.println("networkView already existed.");
    }

    CyNetworkView networkView =  manager.getCurrentNetworkView();
    for (Object o : nodeIds.entrySet()) {
        Map.Entry pairs = (Map.Entry) o;
        CyNode node = (CyNode) pairs.getValue();
        View<CyNode> nodeView = networkView.getNodeView(node);
        nodeView.setLockedValue(BasicVisualLexicon.NODE_SHAPE, NodeShapeVisualProperty.ELLIPSE);
        nodeView.setLockedValue(BasicVisualLexicon.NODE_BORDER_PAINT, Color.BLACK);
        nodeView.setLockedValue(BasicVisualLexicon.NODE_SIZE, 60.0);
    }
}
 

import org.cytoscape.view.model.View; //导入依赖的package包/类
@Override
public TaskIterator createTaskIterator(View<CyEdge> view, CyNetworkView networkView) {
    CytoPanel eastPanel = swingApplication.getCytoPanel(CytoPanelName.EAST);
    eastPanel.setState(CytoPanelState.DOCK);
    int index = eastPanel.indexOfComponent(evidencePanelComponent.getComponent());
    eastPanel.setSelectedIndex(index);

    return new TaskIterator(new NoOpTask());
}
 

import org.cytoscape.view.model.View; //导入依赖的package包/类
@Override
public boolean isReady(View<CyEdge> view, CyNetworkView cyNv) {
    Long suid = view.getModel().getSUID();
    CyTable evTable = getTable(BEL_EVIDENCE_TABLE, tableManager);
    if (evTable == null) return false;

    Collection<CyRow> rows = evTable.getMatchingRows(EDGE_SUID, suid);
    return hasItems(rows);
}
 

import org.cytoscape.view.model.View; //导入依赖的package包/类
public UpdateNodeNameViewTask(View<CyNode> nodeView, CyNetworkView netView, CySwingAppAdapter adapter)
   {
super(nodeView,netView);	
UpdateNodeNameViewTask.netView = netView;
UpdateNodeNameViewTask.nodeView = nodeView;
this.adapter = adapter;
   }
 

import org.cytoscape.view.model.View; //导入依赖的package包/类
public ShowFullEmailNetworkViewTask(View<CyEdge> edgeView, CyNetworkView netView, CySwingAppAdapter myAdapter, int myMode)
   {
super(netView);	
ShowFullEmailNetworkViewTask.netView = netView;
ShowFullEmailNetworkViewTask.edgeView = edgeView;
adapter = myAdapter;
mode = myMode;
   }
 

import org.cytoscape.view.model.View; //导入依赖的package包/类
public ShowAdjacentNodeViewTask(View<CyNode> nodeView, CyNetworkView netView, CySwingAppAdapter adapter)
   {
super(nodeView,netView);	
ShowAdjacentNodeViewTask.netView = netView;
ShowAdjacentNodeViewTask.nodeView = nodeView;
this.adapter = adapter;
   }
 

import org.cytoscape.view.model.View; //导入依赖的package包/类
public ShowFullEmailEdgeViewTask(View<CyEdge> edgeView, CyNetworkView netView, CySwingAppAdapter myAdapter, int myMode)
   {
super(edgeView,netView);
ShowFullEmailEdgeViewTask.netView = netView;
ShowFullEmailEdgeViewTask.edgeView = edgeView;
adapter = myAdapter;
   }
 

import org.cytoscape.view.model.View; //导入依赖的package包/类
@Override
public CyMenuItem createMenuItem(CyNetworkView view, View<CyNode> nodeView) {
	JMenuItem item = new JMenuItem("Extend with CyTargetLinker");
	item.addActionListener(new ActionListener() {
		
		@Override
		public void actionPerformed(ActionEvent e) {
			System.out.println(e.getSource());
		}
	});
	float gravity = 1.0f; 
	CyMenuItem addAsSource = new CyMenuItem(item, gravity); 
	return addAsSource;
}
 

import org.cytoscape.view.model.View; //导入依赖的package包/类
public ExpandNetworkTask(CyNetworkView cyNetworkView, View<CyNode> cyNodeView) 
{
	network = cyNetworkView.getModel();
	columnSelection = getTargetColumns();
	querySelection = new ListSingleSelection<String>("NEIGHBORHOOD","PATHSBETWEEN");
	querySelection.setSelectedValue("NEIGHBORHOOD");
}
 

import org.cytoscape.view.model.View; //导入依赖的package包/类
void setVisibleEdges(Collection<CyEdge> edges, boolean visible, CyNetworkView view) {
	for (CyEdge e : edges) {
		final View<CyEdge> ev = view.getEdgeView(e);   					
		if (visible)
			ev.clearValueLock(EDGE_VISIBLE);
		else
			ev.setLockedValue(EDGE_VISIBLE, false);
	}
}
 

import org.cytoscape.view.model.View; //导入依赖的package包/类
@Override
public TaskIterator createTaskIterator(View<CyNode> nodeView, CyNetworkView networkView) {
	return createTaskIterator(networkView);
}
 

import org.cytoscape.view.model.View; //导入依赖的package包/类
@Override
public boolean isReady(View<CyNode> nodeView, CyNetworkView networkView) {
	return isReady(networkView);
}
 

import org.cytoscape.view.model.View; //导入依赖的package包/类
private static boolean isHidden(View<CyNode> nodeView) {
	if(nodeView == null)
		return false;
	return nodeView.getVisualProperty(BasicVisualLexicon.NODE_VISIBLE) == Boolean.FALSE;
}
 

import org.cytoscape.view.model.View; //导入依赖的package包/类
@Override
	public CyMenuItem createMenuItem(CyNetworkView netView,
			View<CyNode> nodeView) 
	{		
		JMenu submenu = new JMenu ("SPARQL");
		
		MarrsProject project = projectMgr.getProject();
		if (project != null) 
		{				
			CyTable tab = netView.getModel().getDefaultNodeTable();
			CyNode node = nodeView.getModel();
			CyRow row = tab.getRow(node.getSUID());
			
			for (int i = 0; i < project.getRowCount(); ++i)
			{
				MarrsQuery q = project.getRow(i);
				if (q.isContextQuery())
				{
					Map<String, String> queryContext = q.getContext();
					
					boolean nodeMatchesContext = true;
					
					for (String key : queryContext.keySet())
					{
						String expectedValue = queryContext.get(key);
						String actualValue = row.get(key, String.class);
						
						if (!expectedValue.equals(actualValue))
						{
							nodeMatchesContext = false;
						}
					}
					
					if (nodeMatchesContext)
					{
						submenu.add(new QueryAction(q, node, row.get("id", String.class)));
					}
				}
			}							
		}
		
//		JMenuItem menuItem = new JMenuItem("Node View Context Menu Item");
//		menuItem.addActionListener(this);
		CyMenuItem cyMenuItem = new CyMenuItem(submenu, 0);
		return cyMenuItem;
	}