1 // Define a CytoPanel class
   2 public class MyCytoPanel extends JPanel implements CytoPanelComponent {
   3 
   4     ...
   5     @Override
   6     public CytoPanelName getCytoPanelName() {
   7         return CytoPanelName.WEST;
   8     }
   9      ...
  10 }
  11 

   1 // In the start method of your CyActivator class:
   2 //   Create an instance:
   3 MyCytoPanel myPanel = new MyPanel();
   4 //   Register it as a service:
   5 registerService(bc,myCytoPanel,CytoPanelComponent.class, new Properties());
   6 

   1 // Define a CyAction class
   2 public class AddImageIconAction extends AbstractCyAction {
   3         
   4     public AddImageIconAction(CySwingApplication cySwingApplication){
   5         ...
   6         ImageIcon icon = new ImageIcon(getClass().getResource("/images/tiger.jpg"));
   7 
   8         putValue(LARGE_ICON_KEY, icon);
   9        ...
  10     }
  11 
  12     public boolean isInToolBar() {
  13         return true;
  14     }
  15     ...
  16 }
  17 

   1 // In the start method of your CyActivator class:
   2 //   Create an instance:
   3 AddImageIconAction addImageIconAction = new AddImageIconAction(cySwingApplication);
   4 //   Register it as a service:
   5 registerService(bc,addImageIconAction,CyAction.class, new Properties());
   6 

   1 // Define a CyAction class
   2 public class MySubMenuItemAction extends AbstractCyAction {
   3     ...
   4     public MySubMenuItemAction(CySwingApplication cySwingApplication){
   5                 super("My Sub MenuItem...");
   6                 setPreferredMenu("Apps.My MenuItem");
   7                 //setMenuGravity(2.0f);
   8         ...
   9     }
  10 

   1                 // In the start method of your CyActivator class:
   2                 //   Create an instance:
   3                 MySubMenuItemAction action = new MySubMenuItemAction(cySwingApplication);
   4 
   5                 //   Register it as a service:
   6                 registerService(bc,action,CyAction.class, new Properties());
   7 

   1   // To get a reference of CyNetworkFactory at CyActivator class of the App
   2   CyNetworkFactory networkFactory = getService(bc, CyNetworkFactory.class);
   3 ...
   4 
   5   // Create a new network
   6   CyNetwork myNet = networkFactory.createNetwork();
   7   
   8   // Set name for network
   9   myNet.getRow(net).set(CyNetwork.NAME, "My network");
  10 ...
  11 
  12   // Add two nodes to the network
  13   CyNode node1 = myNet.addNode();
  14   CyNode node2 = myNet.addNode();
  15                 
  16   // Set name for new nodes
  17   myNet.getRow(node1).set(CyNetwork.NAME, "Node1");
  18   myNet.getRow(node2).set(CyNetwork.NAME, "Node2");
  19                 
  20   // Add an edge
  21   myNet.addEdge(node1, node2, true);
  22 
  23   // Add the network to Cytoscape
  24   CyNetworkManager networkManager = getService(bc, CyNetworkManager.class);
  25   networkManager.addNetwork(myNet);
  26 

   1   // Get a CyNetworkManager
   2   CyNetworkManager netMgr = getService(bc,CyNetworkManager.class);
   3 

   1   // Destroy a network with NetworkManager
   2   netMgr.destroyNetwork(myNet); 
   3 

   1 //Get the selected nodes
   2   List<CyNode> nodes = CyTableUtil.getNodesInState(myNetwork,"selected",true);
   3 

   1   CyNetwork net = ...;
   2   String name = ...;
   3   net.getRow(net).set(CyNetwork.NAME, name);
   4 

   1   CyNetwork net = ...;
   2   String name = net.getRow(net).get(CyNetwork.NAME, String.class);
   3 

   1   CyNode node = ...;
   2   String myNodeName = ...;
   3   net.getRow(node).set(CyNetwork.NAME, myNodeName);
   4 

   1   CyNode node = ...;
   2   String myNodeName = net.getRow(node).get(CyNetwork.NAME, String.class);
   3 

   1 // Define a task
   2 public class CreateTableTask extends AbstractTask {
   3     ....
   4     @Override
   5     public void run(TaskMonitor tm) throws IOException {
   6         // Step 1: create a new table
   7         CyTable table = tableFactory.createTable("MyAttrTable " + Integer.toString(numImports++), 
   8                                    "name", String.class, true, true);
   9 
  10         // create a column for the table
  11         String attributeName = "MyAttributeName"; 
  12         table.createColumn(attributeName, Integer.class, false);
  13                 
  14         // Step 2: populate the table with some data
  15         String[] keys = {"YLL021W","YBR170C","YLR249W"}; //map to the the "name" column
  16         CyRow row = table.getRow(keys[0]);
  17         row.set(attributeName, new Integer(2));
  18 
  19         row = table.getRow(keys[1]);
  20         row.set(attributeName, new Integer(3));
  21 
  22         row = table.getRow(keys[2]);
  23         row.set(attributeName, new Integer(4));
  24 
  25         // We are loading node attribute
  26         Class<? extends CyTableEntry> type = CyNode.class;
  27 
  28         // Step 3: pass the new table to MapNetworkAttrTask
  29         super.insertTasksAfterCurrentTask( new MapNetworkAttrTask(type,table,netMgr,appMgr,rootNetworkManager) );
  30     }
  31     ....
  32 }
  33 

   1     // case for Node table
   2     CyTable nodeTable = network.getDefaultNodeTable();
   3 

   1     if(nodeTable.getColumn(columnName)!= null){
   2         nodeTable.deleteColumn(columnName);
   3     }   
   4 

   1     /**
   2      * Get all the nodes with a given attribute value.
   3      *
   4      * This method is effectively a wrapper around {@link CyTable#getMatchingRows}.
   5      * It converts the table's primary keys (assuming they are node SUIDs) back to
   6      * nodes in the network.
   7      *
   8      * Here is an example of using this method to find all nodes with a given name:
   9      *
  10      * {@code
  11      *   CyNetwork net = ...;
  12      *   String nodeNameToSearchFor = ...;
  13      *   Set<CyNode> nodes = getNodesWithValue(net, net.getDefaultNodeTable(), "name", nodeNameToSearchFor);
  14      *   // nodes now contains all CyNodes with the name specified by nodeNameToSearchFor
  15      * }
  16      * @param net The network that contains the nodes you are looking for.
  17      * @param table The node table that has the attribute value you are looking for;
  18      * the primary keys of this table <i>must</i> be SUIDs of nodes in {@code net}.
  19      * @param colname The name of the column with the attribute value
  20      * @param value The attribute value
  21      * @return A set of {@code CyNode}s with a matching value, or an empty set if no nodes match.
  22      */
  23     private static Set<CyNode> getNodesWithValue(
  24             final CyNetwork net, final CyTable table,
  25             final String colname, final Object value)
  26     {
  27         final Collection<CyRow> matchingRows = table.getMatchingRows(colname, value);
  28         final Set<CyNode> nodes = new HashSet<CyNode>();
  29         final String primaryKeyColname = table.getPrimaryKey().getName();
  30         for (final CyRow row : matchingRows)
  31         {
  32             final Long nodeId = row.get(primaryKeyColname, Long.class);
  33             if (nodeId == null)
  34                 continue;
  35             final CyNode node = net.getNode(nodeId);
  36             if (node == null)
  37                 continue;
  38             nodes.add(node);
  39         }
  40         return nodes;
  41     }
  42 

   1 import org.cytoscape.model.NetworkTestSupport;
   2 
   3 ...
   4 
   5 final NetworkTestSupport nts = new NetworkTestSupport();
   6 final CyNetwork network = nts.getNetwork();
   7 
   8 // Now you have a CyNetwork!
   9 

   1 // CyTable cyTable = ...
   2 ...
   3 
   4 if(cyTable.getColumn("foo") != null) {
   5 // found
   6 ...
   7 
   8 }
   9 

   1 ...
   2 boolean exists1 = cyNetwork.getDefaultNetworkTable()
   3         .getColumn("foo") != null;
   4 

   1 ...
   2 
   3 boolean exists2 = cyNetwork.getRow(cyNetwork)
   4         .get("foo", fooType) != null; //wrong
   5 boolean exists3 = cyNetwork.getRow(cyNetwork)
   6         .isSet("foo"); //wrong
   7 // - both cannot tell non-existing from null-value attribute.
   8 

   1   CyNetworkView networkView = ...;
   2   CyNetwork network = networkView.getModel();
   3   CyEventHelper eventHelper = ...;
   4   CyNode newNode = network.addNode();
   5   network.getRow(newNode).set(CyNetwork.NAME, "New Node");
   6   eventHelper.flushPayloadEvents();
   7   View<CyNode> newNodeView = networkView.getNodeView(newNode);
   8 

   1   CyNetworkView networkView = ...;
   2   CyNetwork network = networkView.getModel();
   3   CyEventHelper eventHelper = ...;
   4   
   5   for (int i = 1; i <= 100; i++) {
   6     CyNode node = network.addNode();
   7     network.getRow(newNode).set(CyNetwork.NAME, "Node " + i);
   8   }
   9   eventHelper.flushPayloadEvents();
  10 

   1   // Get a CyNetworkViewFactory
   2   CyNetworkViewFactory networkViewFactory = getService(bc, CyNetworkViewFactory.class);
   3 

   1   // Create a new network view
   2   CyNetworkView myView = networkViewFactory.createNetworkView(myNet);
   3 
   4   // Add view to Cytoscape
   5   CyNetworkViewManager networkViewManager = getService(bc, CyNetworkViewManager.class);
   6   networkViewManager.addNetworkView(myView);
   7 

   1   // get a CyNetworkViewManager
   2   CyNetworkViewManager networkViewManager = getService(bc, CyNetworkViewManager.class);
   3 

   1   // destroy a network view through NetworkViewManager
   2   networkViewManager.destroyNetworkView(myView);
   3 

   1   // Set the background of current view to RED  
   2   view.setVisualProperty(BasicVisualLexicon.NETWORK_BACKGROUND_PAINT, Color.red);
   3   view.updateView(); 
   4 

   1 // Get the scale and adjust
   2 double newScale = view.getVisualProperty(NETWORK_SCALE_FACTOR).doubleValue() * scale;
   3 view.setVisualProperty(NETWORK_SCALE_FACTOR, newScale);
   4 ...     
   5 view.updateView();
   6 

   1 View<CyNode> nodeView = ...;
   2 Double x = nodeView.getVisualProperty(BasicVisualLexicon.NODE_X_LOCATION);
   3 Double y = nodeView.getVisualProperty(BasicVisualLexicon.NODE_Y_LOCATION);
   4 

   1 View<CyNode> nodeView = ...;
   2 double x = ...;
   3 double y = ...;
   4 nodeView.setVisualProperty(BasicVisualLexicon.NODE_X_LOCATION, x);
   5 nodeView.setVisualProperty(BasicVisualLexicon.NODE_Y_LOCATION, y);
   6 

   1   // Define a layout class
   2   public class MyLayout extends AbstractLayoutAlgorithm {
   3     ...
   4   }
   5 
   6 
   7   // Define a layout task class
   8   public class MyLayoutTask extends AbstractLayoutTask {
   9     ...
  10 
  11     //Perform actual layout task
  12     final protected void doLayout(final TaskMonitor taskMonitor) {
  13       ...   
  14     }
  15     ...
  16   }
  17 
  18 
  19   // Register the layout class as a service in CyActivator class
  20   Properties myLayoutProps = new Properties();
  21   myLayoutProps.setProperty("preferredMenu","My Layouts");
  22   registerService(bc,myLayout,CyLayoutAlgorithm.class, myLayoutProps);
  23 

   1   // Define a class MyNodeViewTaskFactory 
   2   public class MyNodeViewTaskFactory extends AbstractNodeViewTaskFactory {
   3     ...
   4   }
   5 
   6 
   7   // Register myNodeViewTaskFactory as a service in CyActivator
   8   Properties myNodeViewTaskFactoryProps = new Properties();
   9   myNodeViewTaskFactoryProps.setProperty("title","My context menu title");
  10   registerService(bc,myNodeViewTaskFactory,NodeViewTaskFactory.class, myNodeViewTaskFactoryProps);
  11 

   1     public enum RedoLayout {
   2         YES, NO
   3     };
   4     public enum RedoVisualStyle {
   5         YES, NO
   6     };
   7  
   8     /**
   9      * Update a given CyNetworkView including optionally updating its layout and visual style.
  10      * @param view the CyNetworkView to layout
  11      * @param redoVS if redoVS=RedoVisualStyle.YES, apply the visual style associated with view.
  12      * @param redoLayout if redoLayout=RedoLayout.YES, apply the CyLayoutAlgorithm specified by layoutAlgorName
  13      *                   to view. If RedoLayout.NO, no layout is performed.
  14      * @param layoutAlgorName the name of the layout algorithm to apply. if null, the default
  15      *                        layout algorithm is used. If redoLayout=RedoLayout.NO
  16      *                        layoutAlgorName is ignored.
  17      * @throws IllegalArgumentException if layoutAlgorName is non-null, redoLayout=RedoLayout.YES, and no
  18      *                                  layout algorithm is found.
  19      */
  20     public static void updateView(CyNetworkView view, RedoVisualStyle redoVS, RedoLayout redoLayout, String layoutAlgorName) {
  21         if (redoLayout == RedoLayout.YES) {
  22             final CyLayoutAlgorithmManager alMan = _adapter.getCyLayoutAlgorithmManager();
  23             CyLayoutAlgorithm algor = null;           
  24             if (layoutAlgorName == null) {
  25                 algor = alMan.getDefaultLayout();               
  26             } else {
  27                 algor = alMan.getLayout(layoutAlgorName);
  28             }
  29             if (algor == null) {
  30                 throw new IllegalArgumentException ("No such algorithm found '" + layoutAlgorName + "'.");
  31             }
  32             TaskIterator itr = algor.createTaskIterator(view,
  33                                                           algor.createLayoutContext(),
  34                                                           CyLayoutAlgorithm.ALL_NODE_VIEWS,
  35                                                           null);
  36             _adapter.getTaskManager().execute(itr);
  37             // We use the synchronous task manager otherwise the visual style and updateView()
  38             // may occur before the view is relayed out:
  39             SynchronousTaskManager<?> synTaskMan = _adapter.getCyServiceRegistrar().getService(SynchronousTaskManager.class);           
  40             synTaskMan.execute(itr);           
  41         }
  42         if (redoVS == RedoVisualStyle.YES) {
  43             _adapter.getVisualMappingManager().getVisualStyle(view).apply(view);
  44         }
  45         view.updateView();
  46     }
  47 

   1 boolean isVisible(View<CyEdge> edgeView, CyNetworkView networkView) {
   2         boolean visibleByEdgeProp = edgeView.getVisualProperty(BasicVisualLexicon.EDGE_VISIBLE);
   3         if (!visibleByEdgeProp) {
   4                 return false;
   5         }
   6         CyEdge model = edgeView.getModel();
   7         CyNode source = model.getSource();
   8         CyNode target = model.getTarget();
   9         View<CyNode> sourceView = networkView.getNodeView(source);
  10         View<CyNode> targetView = networkView.getNodeView(target);
  11         boolean visibleBySourceProp = sourceView.getVisualProperty(BasicVisualLexicon.NODE_VISIBLE);
  12         boolean visibleByTargetProp = targetView.getVisualProperty(BasicVisualLexicon.NODE_VISIBLE);
  13         if (!visibleBySourceProp || !visibleByTargetProp) {
  14                 return false;
  15         }
  16         return true;
  17 }
  18 

   1 import org.cytoscape.model.CyNode;
   2 import org.cytoscape.model.CyEdge;
   3 import org.cytoscape.model.CyIdentifiable;
   4 
   5 import org.cytoscape.view.model.CyNetworkView;
   6 import org.cytoscape.view.model.View;
   7 import org.cytoscape.view.model.VisualProperty;
   8 
   9 class DelayedVizProp {
  10   final CyIdentifiable netObj;
  11   final VisualProperty<?> prop;
  12   final Object value;
  13   final boolean isLocked;
  14 
  15   /**
  16    * Specify the desired visual property value for a node or edge.
  17    * @param netObj A CyNode or CyEdge
  18    * @param prop The visual property whose value you want to assign
  19    * @param value The visual property value you want to assign
  20    * @param isLocked true if you want the value to be set as a bypass value, false if you want the value to persist until a visual style is applied to the network view
  21    */
  22   public DelayedVizProp(final CyIdentifiable netObj, final VisualProperty<?> prop, final Object value, final boolean isLocked) {
  23     this.netObj = netObj;
  24     this.prop = prop;
  25     this.value = value;
  26     this.isLocked = isLocked;
  27   }
  28 
  29   /**
  30    * Assign the visual properties stored in delayedProps to the given CyNetworkView.
  31    * @param netView The CyNetworkView that contains the nodes and edges for which you want to assign the visual properties
  32    * @param delayedProps A series of DelayedVizProps that specifies the visual property values of nodes and edges
  33    */
  34   public static void applyAll(final CyNetworkView netView, final Iterable<DelayedVizProp> delayedProps) {
  35     for (final DelayedVizProp delayedProp : delayedProps) {
  36       final Object value = delayedProp.value;
  37       if (value == null)
  38         continue;
  39       
  40       View<?> view = null;
  41       if (delayedProp.netObj instanceof CyNode) {
  42         final CyNode node = (CyNode) delayedProp.netObj;
  43         view = netView.getNodeView(node);
  44       } else if (delayedProp.netObj instanceof CyEdge) {
  45         final CyEdge edge = (CyEdge) delayedProp.netObj;
  46         view = netView.getEdgeView(edge);
  47       }
  48 
  49       if (delayedProp.isLocked) {
  50         view.setLockedValue(delayedProp.prop, value);
  51       } else {
  52         view.setVisualProperty(delayedProp.prop, value);
  53       }
  54     }
  55   }
  56 }
  57 

   1   // To get references to services in CyActivator class
   2   VisualMappingManager vmmServiceRef = getService(bc,VisualMappingManager.class);
   3                 
   4   VisualStyleFactory visualStyleFactoryServiceRef = getService(bc,VisualStyleFactory.class);
   5                 
   6   VisualMappingFunctionFactory vmfFactoryC = getService(bc,VisualMappingFunctionFactory.class, "(mapping.type=continuous)");
   7   VisualMappingFunctionFactory vmfFactoryD = getService(bc,VisualMappingFunctionFactory.class, "(mapping.type=discrete)");
   8   VisualMappingFunctionFactory vmfFactoryP = getService(bc,VisualMappingFunctionFactory.class, "(mapping.type=passthrough)");
   9 
  10 
  11   // To create a new VisualStyle object and set the mapping function
  12   VisualStyle vs= this.visualStyleFactoryServiceRef.createVisualStyle("My visual style");
  13 
  14 
  15   //Use pass-through mapping
  16   String ctrAttrName1 = "SUID";
  17   PassthroughMapping pMapping = (PassthroughMapping) vmfFactoryP.createVisualMappingFunction(ctrAttrName1, String.class, attrForTest, BasicVisualLexicon.NODE_LABEL);
  18 
  19   vs.addVisualMappingFunction(pMapping);                        
  20 
  21 
  22   // Add the new style to the VisualMappingManager
  23   vmmServiceRef.addVisualStyle(vs);
  24 
  25 
  26   // Apply the visual style to a NetwokView
  27   vs.apply(myNetworkView);
  28   myNetworkView.updateView();
  29 

   1   
   2   // Set node color map to attribute "Degree"
   3   ContinuousMapping mapping = (ContinuousMapping)
   4                 this.continuousMappingFactoryServiceRef.createVisualMappingFunction("Degree", Integer.class, BasicVisualLexicon.NODE_FILL_COLOR);
   5 
   6   // Define the points
   7   Double val1 = 2d;
   8   BoundaryRangeValues<Paint> brv1 = new BoundaryRangeValues<Paint>(Color.RED, Color.GREEN, Color.PINK);
   9 
  10   Double val2 = 12d;
  11   BoundaryRangeValues<Paint> brv2 = new BoundaryRangeValues<Paint>(Color.WHITE, Color.YELLOW, Color.BLACK);
  12                 
  13   // Set the points
  14   mapping.addPoint(val1, brv1);
  15   mapping.addPoint(val2, brv2);
  16 
  17   // add the mapping to visual style            
  18   vs.addVisualMappingFunction(mapping); 
  19 

   1   // get a reference to Cytoscape service -- LoadVizmapFileTaskFactory 
   2   LoadVizmapFileTaskFactory loadVizmapFileTaskFactory =  getService(bc,LoadVizmapFileTaskFactory.class);
   3 

   1   // Use the service to load visual style, 'f' is the File object to hold the visual properties 
   2   Set<VisualStyle> vsSet = loadVizmapFileTaskFactory.loadStyles(f);
   3 

   1   //1. define a file filter (BasicCyFileFilter), to support the reader to read the file with extension '.tc'
   2   HashSet<String> extensions = new HashSet<String>();
   3   extensions.add("tc");
   4   HashSet<String> contentTypes = new HashSet<String>();
   5   contentTypes.add("txt");
   6   String description = "My test filter";
   7   DataCategory category = DataCategory.NETWORK;
   8   BasicCyFileFilter filter = new BasicCyFileFilter(extensions,contentTypes, description, category, swingAdapter.getStreamUtil());
   9 
  10   //2. Create an instance of the ReaderFactory
  11   // Note that extends TCReaderFactory  must implement the interface InputStreamTaskFactory or extends the class  AbstractInputStreamTaskFactory.
  12   // And the defined task must implement CyNetworkReader
  13   TCReaderFactory factory = new TCReaderFactory(filter, swingAdapter.getCyNetworkFactory(), swingAdapter.getCyNetworkViewFactory());
  14 
  15   //3. register the ReaderFactory as an InputStreamTaskFactory.
  16   Properties props = new Properties();
  17   props.setProperty("readerDescription","TC file reader");
  18   props.setProperty("readerId","tcNetworkReader");
  19   swingAdapter.getCyServiceRegistrar().registerService(factory, InputStreamTaskFactory.class, props);
  20 

   1   // Get a Cytoscape service 'DialogTaskManager' in CyActivator class
   2   DialogTaskManager dialogTaskManager = getService(bc, DialogTaskManager.class);
   3 
   4 
   5   // Define a task and set the progress in the run() method
   6   public class MyTask extends AbstractTask {
   7     ...
   8     public void run(final TaskMonitor taskMonitor) {
   9         // Give the task a title.
  10         taskMonitor.setTitle("My task");
  11         ...
  12         taskMonitor.setProgress(0.1);
  13 
  14         // do something here
  15 
  16         ...
  17         taskMonitor.setProgress(1.0);
  18   }
  19 
  20 
  21   // Execute the task through the TaskManager
  22   DialogTaskManager.execute(myTaskFactory);
  23 

   1         @Tunable(description="Node is red?", groups="Appearence")
   2         public boolean isRed;
   3         
   4         @Tunable(description="Scale", groups={"Appearence", "Mappings"})
   5         public double scale = 0.2; // Default value
   6 

   1   // Implements the session event listeners
   2   public class MyClass implements SessionAboutToBeSavedListener, SessionLoadedListener {
   3 
   4       // Save app state in a file
   5       public void handleEvent(SessionAboutToBeSavedEvent e){
   6           // save app state file "myAppStateFile"
   7           ...
   8       }
   9 
  10       // restore app state from a file
  11       public void handleEvent(SessionLoadedEvent e){
  12 
  13         if (e.getLoadedSession().getAppFileListMap() == null || e.getLoadedSession().getAppFileListMap().size() ==0){
  14             return;
  15         }       
  16         List<File> files = e.getLoadedSession().getAppFileListMap().get("myAppStateFile");
  17         ...
  18        }
  19   }
  20  
  21 
  22   // Register the two listeners in the CyActivator class
  23   registerService(bc,myClass,SessionAboutToBeSavedListener.class, new Properties());
  24   registerService(bc,myClass,SessionLoadedListener.class, new Properties());
  25 

   1 class PropsReader extends AbstractConfigDirPropsReader {
   2         public PropsReader(String name, String fileName) {
   3                 super(name, fileName, CyProperty.SavePolicy.CONFIG_DIR);
   4         }
   5 }
   6 

   1 PropsReader propsReader = new PropsReader(“myApp", “myApp.props");
   2 Properties propsReaderServiceProps = new Properties();
   3 propsReaderServiceProps.setProperty("cyPropertyName", “myApp.props");
   4 registerAllServices(context, propsReader, propsReaderServiceProps);
   5 

   1 CyProperty<Properties> cyProperties = getService(bc, CyProperty.class, "(cyPropertyName=myApp.props)");
   2 String propertyValue = cyProperties.getProperty(“myApp.firstProperty”);
   3 

   1   // Define a class, which implements a listener interface
   2   public class MyListenerClass implements NetworkAddedListener {
   3     ....
   4     public void handleEvent(NetworkAddedEvent e){
   5         // do something here
   6     }
   7   }
   8 

   1   // In the `start` method of your `CyActivator` class,
   2   // register the listener in the CyActivator class
   3   registerService(bc,myListenerClass, NetworkAddedListener.class, new Properties());
   4 

   1 registerServiceListener(bc, myserviceListener, "addPropertyService", "removePropertyService", CyProperty.class);
   2 

   1   import org.cytoscape.equations.EquationCompiler;
   2   import org.cytoscape.equations.Interpreter;
   3   import org.cytoscape.equations.EquationParser;
   4 
   5   public class Sample23 {
   6 
   7         public Sample23(EquationCompiler eqCompilerRef, Interpreter interpreterRef){
   8                 final EquationParser theParser = eqCompilerRef.getParser();
   9                 theParser.registerFunction(new IXor());
  10         }
  11   }
  12 

   1 public IXor() {
   2         super(new ArgDescriptor[] {
   3                         new ArgDescriptor(ArgType.INT, "arg1", "A quantity that can be converted to an integer."),
   4                         new ArgDescriptor(ArgType.INT, "arg2", "A quantity that can be converted to an integer."),
   5                 });
   6 

   1 /**                                                                                                                                                                                                                                                  
   2  *  Used to parse the function string.  This name is treated in a case-insensitive manner!                                                                                                                                                           
   3  *  @return the name by which you must call the function when used in an attribute equation.                                                                                                                                                        
   4  */
   5 public String getName() { return "IXOR"; }
   6 
   7 /**                                                                                                                                                                                                                                                  
   8   *  Used to provide help for users.                                                                                                                                                                                                                  
   9   *  @return a description of what this function does                                                                                                                                                                                                
  10   */
  11 public String getFunctionSummary() { return "Returns an integer value that is the exclusive-or of 2 other integer values."; }
  12 

   1 public Class getReturnType() { return Long.class; }
   2 

   1 public Object evaluateFunction(final Object[] args) {
   2         long arg1;
   3         try {
   4                 arg1 = FunctionUtil.getArgAsLong(args[0]);
   5         } catch (final Exception e) {
   6                 throw new IllegalArgumentException("IXOR: can't convert the 1st argument to an integer!");
   7         }
   8 
   9         long arg2;
  10         try {
  11                 arg2 = FunctionUtil.getArgAsLong(args[0]);
  12         } catch (final Exception e) {
  13                 throw new IllegalArgumentException("IXOR: can't convert the 2nd argument to an integer!");
  14         }
  15 
  16         final long result = arg1 ^ arg2;
  17         return (Long)result;
  18 }
  19 

   1 @Api
   2 @Path("/basicgreeting/v1")
   3 public interface GreetingResource {
   4 
   5     @GET
   6     @Produces(MediaType.APPLICATION_JSON)
   7     public SimpleMessage greeting();
   8 }
   9 

   1 public class CyActivator extends AbstractCyActivator {
   2         
   3         …
   4         
   5         public void start(BundleContext bc) 
   6         {
   7                 …
   8                 try {
   9                         registerService(bc, new GreetingResourceImpl(), GreetingResource.class, new Properties());
  10                 }
  11                 catch (Exception e)
  12                 {
  13                         …//Deal with any exceptions here.
  14                 }
  15         }
  16 }
  17 

   1 public class YourTask extends AbstractTask {
   2 
   3         @ProvidesTitle
   4         public String getTitle() { return "Task Title Here"; }
   5 
   6         @Tunable (description="Task Description Here")
   7         public String name = null;
   8 
   9         @Override
  10         public void run(TaskMonitor arg0) throws Exception {
  11                 //Your code here
  12         }
  13 }
  14 

   1 public class YourTaskFactory extends AbstractTaskFactory {
   2 
   3         …
   4         
   5         public boolean isReady() {
   6                 return true;
   7         }
   8         
   9         public TaskIterator createTaskIterator() {
  10                 return new TaskIterator(new SayHelloTask());
  11         }
  12 }
  13 

   1  
   2 public class CyActivator extends AbstractCyActivator {
   3 
   4         …
   5 
   6         public void start(BundleContext bc) throws InvalidSyntaxException {
   7         
   8                 Properties yourTaskFactoryProps = new Properties();
   9                 yourTaskFactoryProps.setProperty(COMMAND_NAMESPACE, SAMPLE_COMMAND_NAMESPACE);
  10                 yourTaskFactoryProps.setProperty(COMMAND, "your_commands_name");
  11                 yourTaskFactoryProps.setProperty(COMMAND_DESCRIPTION, “Your Command’s description”);
  12                 yourTaskFactoryProps.setProperty(PREFERRED_MENU, "Your App");
  13                 yourTaskFactoryProps.setProperty(IN_MENU_BAR, "true");
  14                 yourTaskFactoryProps.setProperty(IN_CONTEXT_MENU, "false");
  15                 yourTaskFactoryProps.setProperty("title", "Your command’s title");
  16 
  17                 TaskFactory yourTaskFactory = new YourTaskFactory();
  18                 registerAllServices(bc, yourTaskFactory, yourTaskFactoryProps);
  19         }
  20 }
  21 

   1   public class WebServiceHelper {
   2   ...
   3         public void addWebServiceClient(final WebServiceClient newFactory,
   4                         final Map properties)
   5         {
   6                 webserviceMap.put(newFactory, properties);
   7         }
   8 
   9         public void removeWebServiceClient(final WebServiceClient factory,
  10                         final Map properties)
  11         {
  12                 webserviceMap.remove(factory);
  13         }
  14   ...
  15   }  
  16 

   1   Iterator<WebServiceClient> it = webserviceMap.keySet().iterator();
   2                 
   3   while (it.hasNext()){
   4     WebServiceClient client = it.next();
   5     // Based on the serviceLocation, we can find if the client we are looking for is available
   6     System.out.println("WebService CLient client: DisplayName() is "+client.getDisplayName());
   7     System.out.println("WebService CLient client: ServiceLocation() is "+client.getServiceLocation());
   8     ....  
   9   }
  10 

   1   public class MyWebserviceClientPanel extends JPanel implements ColumnCreatedListener, ColumnDeletedListener,
   2     SetCurrentNetworkListener {
   3   ...
   4 }
   5 

   1   public class MyWebserviceClient extends AbstractWebServiceGUIClient implements TableImportWebServiceClient {
   2   ...
   3   }
   4 

   1 import java.net.ProxySelector;
   2 import org.apache.http.impl.client.HttpClientBuilder;
   3 import org.apache.http.impl.client.CloseableHttpClient;
   4 import org.apache.http.impl.conn.SystemDefaultRoutePlanner;
   5 
   6 ...
   7 
   8 final CloseableHttpClient client = 
   9     HttpClientBuilder.create()
  10       .setRoutePlanner(new SystemDefaultRoutePlanner(ProxySelector.getDefault())) // use JVM's proxy settings
  11       // add more stuff here later to configure the client
  12       .build();
  13 

   1 import org.apache.http.client.methods.HttpRequestBase;
   2 import org.apache.http.client.methods.HttpGet;
   3 
   4 ...
   5 
   6 final String url = ...;
   7 final HttpRequestBase req = new HttpGet(url); /* Or use HttpPost, HttpPut, etc. See the org.apache.http.client.methods package for other classes. */
   8 final CloseableHttpResponse resp = client.execute(req);
   9 

   1 import java.io.ByteArrayOutputStream;
   2 import java.io.ByteArrayInputStream;
   3 
   4 import org.apache.http.client.methods.HttpPost;
   5 import org.apache.http.entity.InputStreamEntity;
   6 import org.apache.http.entity.ContentType;
   7 
   8 import com.fasterxml.jackson.databind.ObjectMapper;
   9 import com.fasterxml.jackson.core.JsonFactory;
  10 import com.fasterxml.jackson.core.JsonGenerator;
  11 import com.fasterxml.jackson.core.JsonEncoding;
  12 import com.fasterxml.jackson.core.TreeNode;
  13 import com.fasterxml.jackson.core.JsonEncoding;
  14 
  15 ...
  16 
  17 final String url = ...;
  18 final TreeNode jsonObject = ...; /* build the JSON object you want to send here */
  19 
  20 // serialize the jsonObject to a byte array
  21 final ByteArrayOutputStream output = new ByteArrayOutputStream();
  22 final ObjectMapper mapper = new ObjectMapper();
  23 final JsonFactory jsonFactory = mapper.getFactory();
  24 final JsonGenerator generator = jsonFactory.createGenerator(output, JsonEncoding.UTF8);
  25 generator.writeTree(jsonObject);
  26 output.flush();
  27 output.close();
  28 // we have a byte array of jsonObject, so now create an HttpEntity with our byte array
  29 final ByteArrayInputStream input = new ByteArrayInputStream(output.toByteArray());
  30 final HttpPost post = new HttpPost(url);
  31 post.setEntity(new InputStreamEntity(input, ContentType.APPLICATION_JSON));
  32 

   1 final int statusCode = resp.getStatusLine().getStatusCode();
   2 if (200 <= statusCode && statusCode < 300) {
   3   // request succeeded!
   4 } else {
   5   // request failed :(
   6 }
   7