import prefuse.data.expression.Predicate; //导入依赖的package包/类
@Override
public void run( Graph graph )
{
    // add the GRAPH to the visualization
    m_vis.add( GRAPH, graph );

    // hide edges
    Predicate edgesPredicate = (Predicate) ExpressionParser.parse( "ingroup('graph.edges') AND [" + USES_EDGES + "]==false", true );
    m_vis.setVisible( GRAPH_EDGES, edgesPredicate, false );

    m_vis.setInteractive( GRAPH_EDGES, null, false );

    // make node interactive
    m_vis.setInteractive( GRAPH_NODES, null, true );

    // add LABELS to the visualization
    Predicate labelP = (Predicate) ExpressionParser.parse( "VISIBLE()" );
    m_vis.addDecorators( LABELS, GRAPH_NODES, labelP, LABEL_SCHEMA );

    run();
}
 

import prefuse.data.expression.Predicate; //导入依赖的package包/类
static final public Expression XorExpression() throws ParseException {
Expression l, r;
  l = AndExpression();
  label_2:
  while (true) {
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case XOR:
      ;
      break;
    default:
      jj_la1[2] = jj_gen;
      break label_2;
    }
    jj_consume_token(XOR);
    r = AndExpression();
    if ( l instanceof XorPredicate ) {
        ((XorPredicate)l).add((Predicate)r);
    } else {
        l = new XorPredicate((Predicate)l,(Predicate)r);
    }
  }
     {if (true) return l;}
  throw new Error("Missing return statement in function");
}
 

import prefuse.data.expression.Predicate; //导入依赖的package包/类
/**
 * Get a filtered iterator over the tuples in the given set,
 * filtered by the given predicate.
 * @param ts the TupleSet to iterate over
 * @param p the filter predicate
 * @return a filtered iterator over the tuples
 */
public static Iterator<Tuple> tuples(TupleSet ts, Predicate p) {
    // no predicate means no filtering
    if ( p == null )
        return ts.tuples();
    
    // attempt to generate an optimized query plan
    Iterator<Tuple> iter = null;
    if ( ts instanceof Table ) {
        Table t = (Table)ts;
        IntIterator ii = getOptimizedIterator(t,p);
        if ( ii != null )
            iter = t.tuples(ii);
    }
    
    // optimization fails, scan the entire table
    if ( iter == null ) {
        iter = new FilterIterator(ts.tuples(), p);
    }
    
    return iter;
}
 

import prefuse.data.expression.Predicate; //导入依赖的package包/类
protected static IntIterator getAndIterator(Table t, AndPredicate ap) {
    // possible TODO: add scoring to select best optimized iterator
    // for now just work from the end backwards and take the first
    // optimized iterator we find
    IntIterator rows = null;
    Predicate clause = null;
    for ( int i=ap.size(); --i >= 0; ) {
        clause = ap.get(i);
        if ( (rows=getOptimizedIterator(t,clause)) != null )
            break;
    }
    
    // exit if we didn't optimize
    if ( rows == null ) return null;
    
    // if only one clause, no extras needed
    if ( ap.size() == 1 ) return rows;
    
    // otherwise get optimized source, run through other clauses
    return new FilterRowIterator(rows, t, ap.getSubPredicate(clause));
}
 

import prefuse.data.expression.Predicate; //导入依赖的package包/类
public GridMinusCircle(double circle_r, String m_group, String filter)
{
	super(m_group);
	this.line_spacing = 10;
	this.circle_r = circle_r;
	this.find_circle_center = true;
	filter = filter + " and visible() and isnode()";
	this.m_filter = (Predicate)ExpressionParser.parse(filter);
}
 

import prefuse.data.expression.Predicate; //导入依赖的package包/类
public void setFilterPredicate(Predicate p)
{
	ip_graph_lock.lock();
	filter_predicate = p;
	updateFilterColumn();
	ip_graph_lock.unlock();
}
 

import prefuse.data.expression.Predicate; //导入依赖的package包/类
/**
 * Add a data set to this visualization, using the given data group name.
 * A visual abstraction of the data will be created and registered with
 * the visualization. An exception will be thrown if the group name is
 * already in use.
 * @param group the data group name for the visualized data
 * @param data the data to visualize
 * @param filter a filter Predicate determining which data Tuples in the
 * input data set are visualized
 * @return a visual abstraction of the input data, a VisualTupleSet
 * instance
 */
public synchronized VisualTupleSet add(
        String group, TupleSet data, Predicate filter)
{
    if ( data instanceof Table ) {
        return addTable(group, (Table)data, filter);
    } else if ( data instanceof Tree ) {
        return addTree(group, (Tree)data, filter);
    } else if ( data instanceof Graph ) {
        return addGraph(group, (Graph)data, filter);
    } else {
        throw new IllegalArgumentException("Unsupported TupleSet type.");
    }
}
 

import prefuse.data.expression.Predicate; //导入依赖的package包/类
/**
 * Adds a graph to this visualization, using the given data group
 * name. A visual abstraction of the data will be created and registered
 * with the visualization. An exception will be thrown if the group name
 * is already in use.
 * @param group the data group name for the visualized graph. The nodes
 * and edges will be available in the "group.nodes" and "group.edges"
 * subgroups.
 * @param graph the graph to visualize
 * @param filter a filter Predicate determining which data Tuples in the
 * input graph are visualized
 * @param nodeSchema the data schema to use for the visual node table
 * @param edgeSchema the data schema to use for the visual edge table
 */
public synchronized VisualGraph addGraph(String group, Graph graph,
        Predicate filter, Schema nodeSchema, Schema edgeSchema)
{
	checkGroupExists(group); // check before adding sub-tables
    String ngroup = PrefuseLib.getGroupName(group, Graph.NODES); 
    String egroup = PrefuseLib.getGroupName(group, Graph.EDGES);

    VisualTable nt, et;
    nt = addTable(ngroup, graph.getNodeTable(), filter, nodeSchema);
    et = addTable(egroup, graph.getEdgeTable(), filter, edgeSchema);
    
    VisualGraph vg = new VisualGraph(nt, et, 
            graph.isDirected(), graph.getNodeKeyField(),
            graph.getEdgeSourceField(), graph.getEdgeTargetField());
    vg.setVisualization(this);
    vg.setGroup(group);
 
    addDataGroup(group, vg, graph);
    
    TupleManager ntm = new TupleManager(nt, vg, TableNodeItem.class);
    TupleManager etm = new TupleManager(et, vg, TableEdgeItem.class);
    nt.setTupleManager(ntm);
    et.setTupleManager(etm);
    vg.setTupleManagers(ntm, etm);
    
    return vg;
}
 

import prefuse.data.expression.Predicate; //导入依赖的package包/类
/**
 * Adds a tree to this visualization, using the given data group
 * name. A visual abstraction of the data will be created and registered
 * with the visualization. An exception will be thrown if the group name
 * is already in use.
 * @param group the data group name for the visualized tree. The nodes
 * and edges will be available in the "group.nodes" and "group.edges"
 * subgroups.
 * @param tree the tree to visualize
 * @param filter a filter Predicate determining which data Tuples in the
 * input graph are visualized
 * @param nodeSchema the data schema to use for the visual node table
 * @param edgeSchema the data schema to use for the visual edge table
 */
public synchronized VisualTree addTree(String group, Tree tree,
        Predicate filter, Schema nodeSchema, Schema edgeSchema)
{
	checkGroupExists(group); // check before adding sub-tables
    String ngroup = PrefuseLib.getGroupName(group, Graph.NODES); 
    String egroup = PrefuseLib.getGroupName(group, Graph.EDGES);
    
    VisualTable nt, et;
    nt = addTable(ngroup, tree.getNodeTable(), filter, nodeSchema);
    et = addTable(egroup, tree.getEdgeTable(), filter, edgeSchema);

    VisualTree vt = new VisualTree(nt, et, tree.getNodeKeyField(),
            tree.getEdgeSourceField(), tree.getEdgeTargetField());
    vt.setVisualization(this);
    vt.setGroup(group);
    
    addDataGroup(group, vt, tree);
    
    TupleManager ntm = new TupleManager(nt, vt, TableNodeItem.class);
    TupleManager etm = new TupleManager(et, vt, TableEdgeItem.class);
    nt.setTupleManager(ntm);
    et.setTupleManager(etm);
    vt.setTupleManagers(ntm, etm);
    
    return vt;
}
 

import prefuse.data.expression.Predicate; //导入依赖的package包/类
/**
    * Get an iterator over all items in the given group which match the given
    * Predicate filter.
    * @param group the visual data group to iterate over
    * @param filter a Predicate indicating which items should be included in
    * the iteration.
    * @return a filtered iterator over VisualItems
    */
   @SuppressWarnings("unchecked")
public Iterator<VisualItem> items(String group, Predicate filter) {
       if ( ALL_ITEMS.equals(group) )
           return items(filter);

       TupleSet t = getGroup(group);
       return (Iterator<VisualItem>) ( t==null ? Collections.<VisualItem>emptyList().iterator() 
                        : t.tuples(filter) );
   }
 

import prefuse.data.expression.Predicate; //导入依赖的package包/类
/**
 * Sets the visbility status for all items in a given data group matching
 * a given filter predicate.
 * @param group the visual data group name
 * @param p the filter predicate determining which items to modify
 * @param value the visibility value to set
 */
public void setVisible(String group, Predicate p, boolean value) {
    Iterator<VisualItem> items = items(group, p);
    while ( items.hasNext() ) {
        VisualItem item = items.next();
        item.setVisible(value);
    }
}
 

import prefuse.data.expression.Predicate; //导入依赖的package包/类
/**
 * Sets the interactivity status for all items in a given data group
 * matching a given filter predicate.
 * @param group the visual data group name
 * @param p the filter predicate determining which items to modify
 * @param value the interactivity value to set
 */
public void setInteractive(String group, Predicate p, boolean value) {
    Iterator<VisualItem> items = items(group, p);
    while ( items.hasNext() ) {
        VisualItem item = items.next();
        item.setInteractive(value);
    }
}
 

import prefuse.data.expression.Predicate; //导入依赖的package包/类
/**
 * Creates a new Display associated with the given Visualization that draws all VisualItems in the visualization that pass the given Predicate.
 * 
 * @param visualization
 *            the {@link Visualization} backing this Display
 * @param predicate
 *            the filtering {@link prefuse.data.expression.Predicate}
 */
public PDisplay(Context context, Visualization visualization, Predicate predicate)
{
	super(context);
	// setDoubleBuffered(false);
	setBackgroundColor(android.graphics.Color.WHITE);

	// initialize text editor
	m_editing = false;
	m_editor = new EditText(context);
	m_editor.setVisibility(View.GONE);

	// register input event capturer TODO for Dritan: implement Event

	// Sets up interactions
	mScaleGestureDetector = new ScaleGestureDetector(context, mScaleGestureListener);
	mGestureDetector = new GestureDetectorCompat(context, mGestureListener);

	// invalidate the display when the filter changes
	m_predicate.addExpressionListener(new UpdateListener()
	{
		public void update(Object src)
		{
			damageReport();
		}
	});

	setVisualization(visualization);
	setPredicate(predicate);
	setSize(400, 400); // set a default size
}
 

import prefuse.data.expression.Predicate; //导入依赖的package包/类
/**
 * Returns the filtering Predicate used to control what items are drawn by this display.
 * 
 * @return the filtering {@link prefuse.data.expression.Predicate}
 */
public Predicate getPredicate()
{
	if (m_predicate.size() == 1)
	{
		return BooleanLiteral.TRUE;
	} else
	{
		return m_predicate.get(0);
	}
}
 

import prefuse.data.expression.Predicate; //导入依赖的package包/类
/**
 * Sets the filtering Predicate used to control what items are drawn by this Display.
 * 
 * @param p
 *            the filtering {@link prefuse.data.expression.Predicate} to use
 */
public synchronized void setPredicate(Predicate p)
{
	if (p == null)
	{
		m_predicate.set(VisiblePredicate.TRUE);
	} else
	{
		m_predicate.set(new Predicate[]
		{ p, VisiblePredicate.TRUE });
	}
}
 

import prefuse.data.expression.Predicate; //导入依赖的package包/类
/**
 * Get a filtered iterator over the edges and nodes of this graph.
 * @see prefuse.data.tuple.TupleSet#tuples(prefuse.data.expression.Predicate)
 */
public Iterator tuples(Predicate filter) {
    if ( filter == null ) {
        return tuples();
    } else {
        return new CompositeIterator(
                m_edgeTuples.iterator(getEdgeTable().rows(filter)),
                m_nodeTuples.iterator(getNodeTable().rows(filter)));
    }
}
 

import prefuse.data.expression.Predicate; //导入依赖的package包/类
/**
    * Create a new CascadedTable.
    * @param parent the parent Table to use
    * @param rowFilter a Predicate determining which rows of the parent
    * table to include in this one.
    * @param colFilter a ColumnProjection determining which columns of the
    * parent table to include in this one.
    * @param tupleType the class type of the Tuple instances to use
    */
   @SuppressWarnings("rawtypes")
protected CascadedTable(Table parent, Predicate rowFilter, 
           ColumnProjection colFilter, Class tupleType)
   {
       super(0, 0, tupleType);
       m_parent = parent;
       m_pnames = new ArrayList<String>();
       m_rows = new CascadedRowManager(this);
       m_listener = new Listener();
       
       setColumnProjection(colFilter);
       setRowFilter(rowFilter);
       m_parent.addTableListener(m_listener);
   }
 

import prefuse.data.expression.Predicate; //导入依赖的package包/类
/**
 * Sets the Predicate determining which rows of the parent
 * table are included in this one.
 * @param rowFilter a Predicate determining which rows of the parent
 * table to include in this one.
 */
public void setRowFilter(Predicate rowFilter) {
	if ( m_rowFilter != null ) {
		m_rowFilter.removeExpressionListener(m_listener);
	}
    m_rowFilter = rowFilter==null ? BooleanLiteral.TRUE : rowFilter;
    if ( m_rowFilter != BooleanLiteral.TRUE )
        m_rowFilter.addExpressionListener(m_listener);
    filterRows();
}
 

import prefuse.data.expression.Predicate; //导入依赖的package包/类
/**
 * @see prefuse.data.tuple.TupleSet#tuples(prefuse.data.expression.Predicate)
 */
public Iterator<Tuple> tuples(Predicate filter) {
    if ( filter == null ) {
        return tuples();
    } else {
        return FilterIteratorFactory.tuples(this, filter);
    }
}
 

import prefuse.data.expression.Predicate; //导入依赖的package包/类
/**
 * @see prefuse.data.tuple.TupleSet#tuples(prefuse.data.expression.Predicate)
 */
public Iterator<Tuple> tuples(Predicate filter) {
    CompositeIterator<Tuple> ci = new CompositeIterator<Tuple>(m_map.size());
    Iterator<Entry<String, TupleSet>> it = m_map.entrySet().iterator();
    for ( int i=0; it.hasNext(); ++i )  {
    	Entry<String, TupleSet> entry = it.next();
        TupleSet ts = entry.getValue();
        ci.setIterator(i, ts.tuples(filter));
    }
    return ci;
}