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 desktopApp){
   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(cytoscapeDesktopService);
   4 //   Register it as a service:
   5 registerService(bc,addImageIconAction,CyAction.class, new Properties());
   6 

   1 // Define a CyAction class
   2 public class Sample04 extends AbstractCyAction {
   3     ...
   4     public Sample04(CySwingApplication desktopApp){
   5         // Add a sub-menu item -- Apps->Sample04->sample04
   6         super("sample04...");
   7         setPreferredMenu("Apps.Sample04");
   8         //Specify the menuGravity value to put the menuItem in the desired place
   9         setMenuGravity(2.0f);
  10         ...
  11     }
  12 

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

   1   // To get a reference of CyNetworkFactory at CyActivator class of the App
   2   CyNetworkFactory cyNetworkFactoryServiceRef = getService(bc,CyNetworkFactory.class);
   3 
   4 ...
   5 
   6   // To create a new network
   7   CyNetwork myNet = cnf.createNetwork();
   8 
   9 ...
  10 
  11   // Add two nodes to the network
  12   CyNode node1 = myNet.addNode();
  13   CyNode node2 = myNet.addNode();
  14                 
  15   // set name for new nodes
  16   myNet.getDefaultNodeTable().getRow(node1.getSUID()).set("name", "Node1");
  17   myNet.getDefaultNodeTable().getRow(node2.getSUID()).set("name", "Node2");
  18                 
  19   // Add an edge
  20   myNet.addEdge(node1, node2, true);
  21 

   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.getDefaultNetworkTable().getRow(net.getSUID()).set(CyNetwork.NAME, name);
   4 

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

   1   CyNode node = ...;
   2   String myNodeName = ...;
   3   net.getDefaultNodeTable().getRow(node.getSUID()).set("name", myNodeName);
   4 

   1   CyNode node = ...;
   2   String myNodeName = net.getDefaultNodeTable().getRow(node.getSUID()).get("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 attributeNmae = "MyAttributeName"; 
  12         table.createColumn(attributeNmae, 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(attributeNmae, new Integer(2));
  18 
  19         row = table.getRow(keys[1]);
  20         row.set(attributeNmae, new Integer(3));
  21 
  22         row = table.getRow(keys[2]);
  23         row.set(attributeNmae, 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   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 cyNetworkViewFactoryServiceRef = getService(bc,CyNetworkViewFactory.class);
   3 

   1   // Create a new network view
   2   CyNetworkView myView = cnvf.createNetworkView(myNet);
   3 

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

   1   // destroy a network view through NetworkViewManager
   2   networkViewManager.destroyNetworkView(myView);
   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   // 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   // 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 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  MyNetworkViewTaskFactory myNetworkViewTaskFactory = new MyNetworkViewTaskFactory(applicationManagerManagerServiceRef);
   2 
   3  // Add double click menu to the network view
   4  Properties myNetworkViewTaskFactoryProps = new Properties();           
   5  myNetworkViewTaskFactoryProps.setProperty("preferredAction","OPEN");
   6  myNetworkViewTaskFactoryProps.setProperty("title","my title");
   7 
   8  // Register the service
   9  registerService(bc,myNetworkViewTaskFactory,NetworkViewTaskFactory.class, myNetworkViewTaskFactoryProps);
  10 

   1  // To add a right click menu item on node view, set "preferredAction" to "NEW"
   2  MyNodeViewTaskFactory myNodeViewTaskFactory = new MyNodeViewTaskFactory();
   3 
   4  // Add double click menu item to the node view
   5  Properties myNodeViewTaskFactoryProps = new Properties();              
   6  myNodeViewTaskFactoryProps.setProperty("preferredAction","NEW");
   7  myNodeViewTaskFactoryProps.setProperty("title","my node action");
   8 
   9  // Register the service
  10  registerService(bc,myNodeViewTaskFactory,NodeViewTaskFactory.class, myNodeViewTaskFactoryProps);
  11 

   1 import java.awt.event.ActionEvent;
   2 import java.awt.event.ActionListener;
   3 
   4 import javax.swing.JMenuItem;
   5 import javax.swing.JOptionPane;
   6 
   7 import org.cytoscape.application.swing.CyMenuItem;
   8 import org.cytoscape.application.swing.CyNodeViewContextMenuFactory;
   9 import org.cytoscape.model.CyNode;
  10 import org.cytoscape.view.model.CyNetworkView;
  11 import org.cytoscape.view.model.View;
  12 
  13 public class CyNodeVCMFSample implements CyNodeViewContextMenuFactory, ActionListener{
  14 
  15         @Override
  16         public CyMenuItem createMenuItem(CyNetworkView netView,
  17                         View<CyNode> nodeView) {
  18                 
  19                 JMenuItem jMenu = new JMenuItem("sample CyNodeVCMF");
  20                 jMenu.addActionListener(this);
  21                 CyMenuItem newMenu = new CyMenuItem(jMenu, 1);
  22                 return newMenu;
  23                 
  24         }
  25 
  26         public void actionPerformed(ActionEvent e) {
  27 
  28                 // Write your own function here.
  29                 JOptionPane.showMessageDialog(null, "CyNodeViewContextMenuFactory worked!");
  30                 
  31         }
  32 }
  33 

   1 import java.awt.event.ActionEvent;
   2 import java.awt.event.ActionListener;
   3 
   4 import javax.swing.JMenuItem;
   5 import javax.swing.JOptionPane;
   6 
   7 import org.cytoscape.application.swing.CyEdgeViewContextMenuFactory;
   8 import org.cytoscape.application.swing.CyMenuItem;
   9 import org.cytoscape.model.CyEdge;
  10 import org.cytoscape.view.model.CyNetworkView;
  11 import org.cytoscape.view.model.View;
  12 
  13 public class CyEdgeVCNMFSample implements CyEdgeViewContextMenuFactory, ActionListener  {
  14 
  15         @Override
  16         public CyMenuItem createMenuItem(CyNetworkView netView,
  17                         View<CyEdge> edgeView) {
  18                 JMenuItem newMenuItem = new JMenuItem("Sample cyEdgeVNMF");
  19                 newMenuItem.addActionListener(this);
  20                 CyMenuItem edgeMenu = new CyMenuItem(newMenuItem, 1);
  21                 return edgeMenu;
  22         }
  23 
  24         @Override
  25         public void actionPerformed(ActionEvent e) {
  26                 
  27                 // Write your own function here.
  28                 JOptionPane.showMessageDialog(null, "CyEdgeViewContextMenuFactory action worked!");
  29                 
  30         }
  31         
  32 }
  33 

   1 import java.util.Properties;
   2 
   3 import org.cytoscape.application.swing.CyEdgeViewContextMenuFactory;
   4 import org.cytoscape.application.swing.CyNodeViewContextMenuFactory;
   5 import org.cytoscape.service.util.AbstractCyActivator;
   6 import org.osgi.framework.BundleContext;
   7 
   8 public class CyActivator extends AbstractCyActivator {
   9 
  10         @Override
  11         public void start(BundleContext context) throws Exception {
  12                 CyNodeViewContextMenuFactory cyNodeVCMF  = new CyNodeVCMFSample();
  13                 CyEdgeViewContextMenuFactory cyEdgeVCMF = new CyEdgeVCNMFSample();
  14                 
  15                 Properties properties = new Properties();
  16                 registerAllServices(context, cyNodeVCMF, properties);
  17                 registerAllServices(context, cyEdgeVCMF, properties);
  18                 
  19         }
  20 
  21 }
  22 

   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 
  11   //2. Create an instance of the ReaderFactory
  12   // Note that extends TCReaderFactory  must implement the interface InputStreamTaskFactory or extends the class  AbstractInputStreamTaskFactory.
  13   // And the defined task must implement CyNetworkReader
  14   TCReaderFactory factory = new TCReaderFactory(filter, swingAdapter.getCyNetworkFactory(), swingAdapter.getCyNetworkViewFactory());
  15 
  16   
  17 
  18   //3. register the ReaderFactory as an InputStreamTaskFactory.
  19   Properties props = new Properties();
  20   props.setProperty("readerDescription","TC file reader");
  21   props.setProperty("readerId","tcNetworkReader");
  22   swingAdapter.getCyServiceRegistrar().registerService(factory, InputStreamTaskFactory.class, props);
  23 

   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   // 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         //1. Adding a property which saves the node border width selected by the user.
   2         public static String NodeBorderWidthInPaths = "NODE_BORDER_WIDTH_IN_PATHS";
   3         public static Double NodeBorderWidthInPathsValue = 20.0;
   4         public static Properties nodeBorderWidthProps = new Properties();
   5 
   6         //2. Find if the CyProperty already exists, if not create one with default value.
   7         CyProperty<Properties> nodeBorderWidthProperty = null;
   8         CySessionManager mySessionManager;
   9         mySessionManager = adapter.getCySessionManager();
  10         CySession session;
  11         session = mySessionManager.getCurrentSession();
  12         if(session.equals(null))
  13                 System.out.println("session null");
  14                 
  15         //3. Get all properties and loop through to find your own.
  16         Set<CyProperty<?>> props = new HashSet<CyProperty<?>>();
  17         props = session.getProperties();
  18         if(props.equals(null))
  19                 System.out.println("props null");
  20         boolean flag = false;
  21         
  22         for (CyProperty<?> prop : props) {
  23             if (prop.getName() != null){
  24                 if (prop.getName().equals(NodeBorderWidthInPaths)) {
  25                 nodeBorderWidthProperty = (CyProperty<Properties>) prop;
  26                 flag = true;
  27                 break;
  28                 }
  29             }
  30         }
  31         
  32         //4. If the property does not exists, create nodeBorderWidthProperty
  33         if (!flag)
  34         {
  35                 nodeBorderWidthProps.setProperty(NodeBorderWidthInPaths, NodeBorderWidthInPathsValue.toString());
  36                 nodeBorderWidthProperty = new 
  37                                 SimpleCyProperty(NodeBorderWidthInPaths, 
  38                                                 nodeBorderWidthProps, Float.TYPE, CyProperty.SavePolicy.SESSION_FILE_AND_CONFIG_DIR );
  39         }
  40         //5. If not null, property exists, get value from it and set NodeBorderWidthInPathsValue
  41         else
  42         {
  43                 nodeBorderWidthProps = nodeBorderWidthProperty.getProperties();
  44                 NodeBorderWidthInPathsValue = Double.valueOf((String)nodeBorderWidthProps.get(NodeBorderWidthInPaths));
  45         }
  46 

   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   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.util.Properties;
   2 
   3 import org.cytoscape.application.swing.CyHelpBroker;
   4 import org.cytoscape.service.util.AbstractCyActivator;
   5 import org.osgi.framework.BundleContext;
   6 
   7 public class CyActivator extends AbstractCyActivator {
   8 
   9         @Override
  10         public void start(BundleContext context) throws Exception {
  11                 
  12                 CyHelpBroker cyHelpBroker = getService(context, CyHelpBroker.class);
  13 
  14                 AppHelp action = new AppHelp(cyHelpBroker);
  15                 registerAllServices(context, action, new Properties());
  16         }
  17 
  18 }
  19 

   1 ...
   2 import java.net.URL;
   3 import org.cytoscape.application.swing.CyHelpBroker;
   4 import javax.help.HelpSet;
   5 ...
   6         /**
   7          *  Hook plugin help into the Cytoscape main help system:
   8          */
   9         private void addHelp() {
  10                 final String HELP_SET_NAME = "/help/jhelpset";
  11                 final ClassLoader classLoader = AppHelp.class.getClassLoader();
  12                 URL helpSetURL;
  13                 try {
  14                         helpSetURL = HelpSet.findHelpSet(classLoader, HELP_SET_NAME);
  15                         final HelpSet newHelpSet = new HelpSet(classLoader, helpSetURL);
  16                         cyHelpBroker.getHelpSet().add(newHelpSet);
  17                 } catch (final Exception e) {
  18                         System.err.println("Sample24: Could not find help set: \"" + HELP_SET_NAME + "!");
  19                 }
  20         }
  21 

   1        ...
   2 import cytoscape.view.CyHelpBroker;
   3        ...
   4        CyHelpBroker.getHelpBroker().enableHelpOnButton(helpButton, "Topic", null);
   5        ...
   6