Index: fedd/abac-src/atnvis/src/com/algomagic/atn/VisualizationPanel.java
===================================================================
--- fedd/abac-src/atnvis/src/com/algomagic/atn/VisualizationPanel.java	(revision 8780cbecc6db2bdc2b9ef31eec6e5209ad3bff15)
+++ fedd/abac-src/atnvis/src/com/algomagic/atn/VisualizationPanel.java	(revision 8780cbecc6db2bdc2b9ef31eec6e5209ad3bff15)
@@ -0,0 +1,1000 @@
+package com.algomagic.atn;
+
+import att.grappa.*;
+import java.util.*;
+
+import java.awt.*;
+import java.awt.event.*;
+import java.awt.geom.*;
+
+import javax.swing.*;
+import javax.swing.border.*;
+import javax.swing.event.*;
+
+
+public class VisualizationPanel 
+    extends JPanel 
+    implements Observer, VisualizationConstants {
+
+    private int _side;
+    private Properties _properties;
+
+    private GrappaPanel _grappaPanel;
+    private Graph _graph;
+
+    private JPanel _complete;
+    private JPanel _graphPanel;
+    private CredentialPanel _credentialPanel;
+
+    private ImageIcon _collapse;
+    private ImageIcon _expand;
+
+    private HashMap _nodeStates;
+    private Subgraph _currentCluster;
+
+    private boolean _local;
+    private java.util.List _bolded;
+    private HashMap _remoteClusters;
+    private HashMap _remoteEvidence;
+
+    private HashMap _localClusters;
+    
+    private String _shadowColor;
+    private int _currentIndex;
+
+    private BatchGraphUpdate _batchUpdate;
+    private boolean _ignoreProcessing;
+    private HashSet _boldedNodes;
+    private boolean _basicProps;
+
+    private String _name;
+
+    public void setName( String name ) {
+	_name = name;
+	PanelHelper.setBorder( _graphPanel, "Trust Target Graph: " + name );
+// 	_graph.setAttribute( TIP_ATTR, "Trust Target Graph: " + name );
+// 	_graph.setAttribute( TIP_ATTR, null );
+
+	_grappaPanel.setToolTipText( null );
+    }
+
+
+    class CredentialPanel extends JPanel {
+	JTabbedPane _tabs;
+	JList _local;
+	JList _remote;
+	JList _policy;
+
+	DefaultListModel _localCreds;
+	DefaultListModel _remoteCreds;
+	DefaultListModel _policyCreds;
+
+	boolean _autoRaise;
+
+	public CredentialPanel( ) {
+	    super( );
+
+	    _autoRaise = true;
+
+	    _tabs = new JTabbedPane( );
+
+	    _localCreds = new DefaultListModel( );
+	    _remoteCreds = new DefaultListModel( );
+	    _policyCreds = new DefaultListModel( );
+
+
+	    _local = new JList( _localCreds );
+	    _remote = new JList( _remoteCreds );
+	    _policy = new JList( _policyCreds );
+
+
+	    _tabs.addTab( "Local Credentials", new JScrollPane( _local ) );
+	    _tabs.addTab( "Remote Credentials", new JScrollPane( _remote ) );
+	    _tabs.addTab( "Policies", new JScrollPane( _policy ) );
+
+ 
+	    setLayout( new BorderLayout( ) );
+	    add( _tabs, BorderLayout.CENTER );
+
+	    PanelHelper.setBorder( this, "Credentials" );
+	}
+	
+
+	public void clearSelection( ) {
+	    _local.clearSelection( );
+	    _remote.clearSelection( );
+	}
+
+
+	public void setAutoRaise( boolean state ) {
+	    _autoRaise = state;
+	}
+
+
+	public void setRaised( int tab ) {
+	    clearSelection( );
+
+	    if( _autoRaise ) {
+// 		System.out.println( "side: " + _side + "  tab: " + tab );
+
+		_tabs.setSelectedIndex( tab );
+	    }
+	}
+
+
+	public void setRaised( boolean local ) {
+	    clearSelection( );
+
+	    if( _autoRaise ) {
+		if( local ) {
+		    _tabs.setSelectedIndex( 0 );
+		} else {
+		    _tabs.setSelectedIndex( 1 );
+		}
+	    }
+	}
+	
+
+	public void addCredentials( Collection evidence, int tab ) {
+	    clearSelection( );
+	    DefaultListModel m;
+
+	    if( tab == 0 ) {
+		m = _localCreds;
+	    } else if( tab == 1 ) {
+		m = _remoteCreds;
+	    } else {
+		m = _policyCreds;
+	    }
+
+	    for( Iterator i = evidence.iterator( ); i.hasNext( ); ) {
+		Object o = i.next( );
+
+		if( !m.contains( o ) ) {
+		    m.addElement( o );
+		}
+// 		m.addElement( i.next( ) );
+	    }
+	}
+
+
+	public void removeCredentials( Collection evidence, int tab ) {
+	    clearSelection( );
+	    DefaultListModel m;
+
+	    if( tab == 0 ) {
+		m = _localCreds;
+	    } else if( tab == 1 ) {
+		m = _remoteCreds;
+	    } else {
+		m = _policyCreds;
+	    }
+
+	    for( Iterator i = evidence.iterator( ); i.hasNext( ); ) {
+		Object o = i.next( );
+
+		if( m.contains( o ) ) {
+		    m.removeElement( o );
+		}
+// 		m.addElement( i.next( ) );
+	    }
+	}
+
+
+	public void addCredentials( Collection evidence, boolean local ) {
+	    clearSelection( );
+	    DefaultListModel m;
+
+	    if( local ) {
+		m = _localCreds;
+	    } else {
+		m = _remoteCreds;
+	    }
+
+
+
+
+	    for( Iterator i = evidence.iterator( ); i.hasNext( ); ) {
+		Object o = i.next( );
+
+		if( !m.contains( o ) ) {
+		    m.addElement( o );
+		}
+	    }
+
+	}
+
+
+	public void removeCredentials( Collection evidence, boolean local ) {
+	    clearSelection( );
+	    DefaultListModel m;
+
+	    if( local ) {
+		m = _localCreds;
+	    } else {
+		m = _remoteCreds;
+	    }
+
+
+
+
+	    for( Iterator i = evidence.iterator( ); i.hasNext( ); ) {
+		Object o = i.next( );
+
+		if( m.contains( o ) ) {
+		    m.removeElement( o );
+		}
+	    }
+
+	}
+
+	public void highlightCredentials( Collection evidence, int tab ) {
+
+	    DefaultListModel m;
+	    JList l;
+
+	    if( tab == 0 ) {
+		m = _localCreds;
+		l = _local;
+	    } else {
+		m = _remoteCreds;
+		l = _remote;
+	    }
+
+
+	    clearSelection( );
+
+	    int[] indices = new int[evidence.size( )];
+	    int count = 0;
+	    for( Iterator i = evidence.iterator( ); i.hasNext( ); ) {
+		indices[count] = m.indexOf( i.next( ) );
+		count++;
+	    }
+
+	    l.setSelectedIndices( indices );
+	}
+
+
+	public void highlightCredentials( Collection evidence, boolean local ) {
+	    DefaultListModel m;
+	    JList l;
+
+	    if( local ) {
+		m = _localCreds;
+		l = _local;
+	    } else {
+		m = _remoteCreds;
+		l = _remote;
+	    }
+
+
+	    clearSelection( );
+
+	    int[] indices = new int[evidence.size( )];
+	    int count = 0;
+	    for( Iterator i = evidence.iterator( ); i.hasNext( ); ) {
+		indices[count] = m.indexOf( i.next( ) );
+		count++;
+	    }
+
+	    l.setSelectedIndices( indices );
+
+	}
+
+	public void removeRemoteCreds( ) {
+// 	    System.out.println( "removing remote creds" );
+
+	    _remoteCreds.clear( );
+	}
+
+    }
+
+
+    public void setAutoRaise( boolean state ) {
+	_credentialPanel.setAutoRaise( state );
+    }
+
+    public void clearSelection( ) {
+	_credentialPanel.clearSelection( );
+    }
+
+
+    public void setRaised( boolean local ) {
+	_credentialPanel.setRaised( local );
+    }
+
+    public void setRaised( int tab ) {
+	_credentialPanel.setRaised( tab );
+    }
+
+
+    public void addCredentials( Collection evidence, boolean local ) {
+	if( evidence != null ) {
+	    _credentialPanel.addCredentials( evidence, local );
+	}
+    }
+
+    public void removeCredentials( Collection evidence, boolean local ) {
+	if( evidence != null ) {
+	    _credentialPanel.removeCredentials( evidence, local );
+	}
+    }
+
+
+    public void highlightCredentials( Collection evidence, boolean local ) {
+	if( evidence != null ) {
+	    _credentialPanel.highlightCredentials( evidence, local );
+	}
+    }
+    
+    public void addCredentials( Collection evidence, int tab ) {
+	if( evidence != null ) {
+	    _credentialPanel.addCredentials( evidence, tab );
+	}
+    }
+
+    public void removeCredentials( Collection evidence, int tab ) {
+	if( evidence != null ) {
+	    _credentialPanel.removeCredentials( evidence, tab );
+	}
+    }
+
+    public void highlightCredentials( Collection evidence, int tab ) {
+	if( evidence != null ) {
+	    _credentialPanel.highlightCredentials( evidence, tab );
+	}
+    }
+    
+
+    public VisualizationPanel( int side, Properties properties ) {
+	super( );
+
+	_side = side;
+	_properties = properties;
+	_currentCluster = null;
+	_local = true;
+	_basicProps = false;
+
+	_nodeStates = new HashMap( );
+	_bolded = new ArrayList( );
+	_remoteClusters = new HashMap( );
+	_remoteEvidence = new HashMap( );
+	_localClusters = new HashMap( );
+	_batchUpdate = new BatchGraphUpdate( );
+	_boldedNodes = new HashSet( );
+
+
+	_ignoreProcessing = (new Boolean( _properties.getProperty( IGNOREPROC_PROP, IGNOREPROC_DEFAULT ) )).booleanValue( );
+// 	System.out.println( _properties.getProperty( IGNOREPROC_PROP, IGNOREPROC_DEFAULT ) );
+// 	System.out.println( _ignoreProcessing );
+
+
+	_shadowColor = _properties.getProperty( SHADOW_PROP, SHADOW_DEFAULT );
+
+
+	Class clazz = this.getClass( );
+	_collapse = new ImageIcon( clazz.getResource( "/resources/collapse.gif" ), "collapse" );
+	_expand = new ImageIcon( clazz.getResource( "/resources/expand.gif" ), "expand" );
+
+
+	JPanel hiderPanel = new JPanel( );
+	hiderPanel.setLayout( new BoxLayout( hiderPanel, BoxLayout.X_AXIS ) );
+
+	JButton hider = new JButton( _collapse );
+	hider.setMaximumSize( new Dimension( 2000, 10 ) );
+	hider.setPreferredSize( new Dimension( 2000, 10 ) );
+	hider.setMinimumSize( new Dimension( 0, 10 ) );
+
+	hider.addActionListener( new ActionListener( ) {
+		boolean removed = false;
+		
+		public void actionPerformed( ActionEvent e ) {
+		    JButton button = (JButton)e.getSource( );
+
+		    if( ! removed ) {
+			_complete.remove( _credentialPanel );
+			button.setIcon( _expand );
+			removed = true;
+		    } else {
+			_complete.add( _credentialPanel, 2 );
+			button.setIcon( _collapse );
+			removed = false;
+		    }
+
+		    validate( );
+		    repaint( );
+		}
+
+	    } );
+
+	hiderPanel.add( hider );
+
+	_graph = new Graph( "Trust Target Graph: " + _side );
+
+	_grappaPanel = new GrappaPanel( _graph );
+	_grappaPanel.setScaleToFit( false );
+	
+// 	JScrollPane jsp = new JScrollPane( );
+// 	jsp.getViewport( ).setScrollMode( JViewport.BACKINGSTORE_SCROLL_MODE );
+// 	jsp.getViewport( ).setBackground( Color.white );
+// 	jsp.setViewportView( _grappaPanel );
+	
+	JScrollPane jsp = new JScrollPane( _grappaPanel );
+// 	jsp.getViewport( ).setScrollMode( JViewport.BACKINGSTORE_SCROLL_MODE );
+ 	jsp.getViewport( ).setBackground( Color.white );
+// 	jsp.setViewportView( _grappaPanel );
+	
+
+	_graphPanel = new JPanel( new BorderLayout( ) );
+	PanelHelper.setBorder( _graphPanel, "Trust Target Graph" );
+	_graphPanel.add( jsp, BorderLayout.CENTER );
+
+	
+	_credentialPanel = new CredentialPanel( );
+	_credentialPanel.setMaximumSize( new Dimension( 2000, 150 ) );
+	_credentialPanel.setPreferredSize( new Dimension( 2000, 150 ) );
+	_credentialPanel.setMinimumSize( new Dimension( 0, 150 ) );
+
+	_complete = new JPanel( );
+	_complete.setLayout( new BoxLayout( _complete, BoxLayout.Y_AXIS ) );
+
+	_complete.add( _graphPanel );
+	_complete.add( hiderPanel );
+	_complete.add( _credentialPanel );
+
+
+	_grappaPanel.addGrappaListener( new TipAdapter( ) );
+
+
+	setLayout( new BoxLayout( this, BoxLayout.Y_AXIS ) );
+	add( _complete );
+
+    }
+
+
+
+
+
+    public boolean addNodeState( NodeState ns ) {
+	if( _nodeStates.containsKey( ns.getName( ) ) ) {
+	    return false;
+	}
+
+	_nodeStates.put( ns.getName( ), ns );
+
+	return true;
+    }
+
+    public NodeState getNodeState( String name ) {
+	return (NodeState)_nodeStates.get( name );
+    }
+
+
+
+    public void reset( java.util.List updates ) {
+	_basicProps = true;
+
+	for( ListIterator i = updates.listIterator( ); i.hasNext( ); ) {
+	    Update u = (Update)i.next( );
+
+	    if( u.getSide( ) == _side ) {
+		u.apply( this );
+	    }
+	}
+
+	_basicProps = false;
+	hideGraph( _graph );
+
+    }
+
+
+    public java.util.List initialize( java.util.List updates ) {
+	java.util.List filteredUpdates = new ArrayList( );
+
+	for( ListIterator i = updates.listIterator( ); i.hasNext( ); ) {
+	    Update u = (Update)i.next( );
+	    if( u.getSide( ) == _side ) {
+		int changed = u.initialize( this );
+
+		// if changed == 1, processing state changed
+		//    changed == 2, satisfaction state changed
+		//    changed == 3, processing and satisfaction changed
+		//    changed == 0, no change
+
+
+		if( changed == 3 ||
+		    (!_ignoreProcessing && changed >= 1 ) ||
+		    (_ignoreProcessing && changed >= 2 ) ) {
+
+		    filteredUpdates.add( u );
+		}
+	    } else {
+		filteredUpdates.add( u );
+	    }
+	}
+
+
+	boolean isRemoteCluster = false;
+	int clusterNumber = -1;
+	HashSet remoteCluster = null;
+	Collection remoteEvidence = null;
+
+
+	for( ListIterator i = filteredUpdates.listIterator( ); i.hasNext( ); ) {
+	    Update u = (Update)i.next( );
+	    if( u.getSide( ) == _side ) {
+// 		if( u instanceof NodeUpdate ) {
+// 		    System.out.println( u );
+// 		}
+
+		u.apply( this );
+
+		if( u instanceof ClusterUpdate ) {
+		    ClusterUpdate cu = (ClusterUpdate)u;
+		    if( !cu.getLocal( ) ) {
+			if( cu.getStart( ) ) {
+			    isRemoteCluster = true;
+			    clusterNumber = cu.getCluster( );
+			    remoteCluster = new HashSet( );
+			    remoteEvidence = new ArrayList( );
+			} else {
+			    isRemoteCluster = false;
+			    _remoteClusters.put( new Integer( clusterNumber ), remoteCluster );
+			    _remoteEvidence.put( new Integer( clusterNumber ), remoteEvidence );
+			}
+		    }
+		} else if( isRemoteCluster ) {
+		    remoteCluster.add( u );
+		    if( u instanceof EdgeUpdate ) {
+			Collection c = ((EdgeUpdate)u).getEvidence( );
+			remoteEvidence.addAll( c );
+		    }
+		}
+
+	    }
+	}
+
+
+	formatGraph( _graph );
+ 	hideGraph( _graph );
+	_credentialPanel.removeRemoteCreds( );
+
+
+	String scaleStr = _properties.getProperty( SCALE_PROP, SCALE_DEFAULT );
+	double scale = Double.parseDouble( scaleStr );
+
+	_grappaPanel.multiplyScaleFactor( scale );
+
+	_graph.resync( );
+	_graph.repaint( );
+
+
+	return filteredUpdates;
+    }
+
+
+
+    public PanelUpdate apply( Update u ) {
+	_batchUpdate = new BatchGraphUpdate( );
+
+	if( u.getSide( ) != _side ) {
+	    throw new RuntimeException( );
+	}
+	    
+
+	u.apply( this );	    
+
+	boolean raise = false;
+	int tab = -1;
+
+	boolean add = false;
+	boolean hl = true;
+
+	Collection c = null;
+
+	if( u instanceof ClusterUpdate ) {
+	    ClusterUpdate cu = (ClusterUpdate)u;
+	    if( !cu.getStart( ) && cu.getLocal( ) ) {
+		unSetBolded( !cu.getUndo( ), cu.getCluster( ) );
+	    } else if( cu.getStart( ) && !cu.getLocal( ) ) {
+		setShadowed( !cu.getUndo( ), cu.getCluster( ) );
+		c = (Collection) _remoteEvidence.get( new Integer( cu.getCluster( ) ) );
+		add = true;
+		hl = false;
+	    }
+	}
+
+
+	if( u.getLocal( ) ) {
+	    tab = 0;
+	    raise = true;
+	} else {
+	    tab = 1;
+	    raise = true;
+	}
+
+
+	if( u instanceof EdgeUpdate ) {
+	    EdgeUpdate eu = (EdgeUpdate)u;
+	    c = eu.getEvidence( );
+
+	    if( eu.getType( ).equals( CONTROL_EDGE ) ) {
+		if( u.getLocal( ) ) {
+		    tab = 2;
+		    raise = true;
+		}
+	    }
+	}
+
+
+	    
+	return new PanelUpdate( _batchUpdate, _side, tab, c, raise, add, hl );
+    }
+
+
+    public void update( Observable o, Object arg ) {
+	clearSelection( );
+
+	if( arg instanceof PanelUpdate ) {
+
+	    PanelUpdate u = (PanelUpdate)arg;
+	    if( u.getSide( ) != _side ) {
+ 		return;
+	    }
+
+
+// 	    if( u instanceof ClusterUpdate ) {
+// 		ClusterUpdate cu = (ClusterUpdate)u;
+// 		if( !cu.getStart( ) && cu.getLocal( ) ) {
+// 		    unSetBolded( !cu.getUndo( ), cu.getCluster( ) );
+// 		} else if( cu.getStart( ) && !cu.getLocal( ) ) {
+// 		    setShadowed( !cu.getUndo( ), cu.getCluster( ) );
+// 		}
+// 	    }
+
+	    u.apply( this );
+
+	    _graph.resync( );
+	    _graph.repaint( );
+
+	    
+// 	    if( u.getUndo( ) ) {
+// // 		System.out.println( "UNDO" );
+// 		u.undo( this );
+// 	    } else {
+// 		u.apply( this );	    
+// 	    }
+
+// 	    _graph.resync( );
+// 	    _graph.repaint( );
+
+	} else if( arg instanceof String ) {
+
+	    String s = (String)arg; 
+	    if( s.equals( "CLEAR" ) ) {
+// 		System.out.println( "CLEAR" );
+
+		hideGraph( _graph );
+// 		_credentialPanel.removeRemoteCreds( );
+	    }
+	}
+    }
+
+
+    public Graph getGraph( ) {
+	return _graph;
+    }
+
+    public Subgraph getCurrentCluster( ) {
+	return _currentCluster;
+    }
+
+    public void setCurrentCluster( Subgraph sg ) {
+	_currentCluster = sg;
+    }
+
+
+
+
+
+    private void setShadowed( boolean shadow, int clusterNum ) {
+	HashSet cluster  = (HashSet)_remoteClusters.get( new Integer( clusterNum ) );
+
+	for( Iterator i = cluster.iterator( ); i.hasNext( ); ) {
+	    Update u = (Update)i.next( );
+
+	    if( u instanceof NodeUpdate ) {
+		NodeUpdate nu = (NodeUpdate)u;
+
+		NodeState ns = getNodeState( nu.getName( ) );
+		if( ns.getHidden( ) == false ) {
+		    continue;
+		}
+
+	    }
+
+	    Element e = u.getElement( this );
+
+	    if( shadow ) {
+		setShadow( e );
+	    } else {
+		setInvis( e );
+	    }
+
+	    if( u instanceof EdgeUpdate ) {
+		EdgeUpdate eu = (EdgeUpdate)u;
+
+		NodeState ns = getNodeState( eu.getChildName( ) );
+		if( ns.getHidden( ) == false ) {
+		    continue;
+		}
+
+		e = eu.getChild( this );
+		
+		if( shadow ) {
+		    setShadow( e );
+		} else {
+		    setInvis( e );
+		}
+
+	    }
+
+
+	}
+
+
+    }
+
+
+
+    public void setShadow( Element e ) {
+	setAttribute( e, "color", _shadowColor );
+	setAttribute( e, "style", "solid" );
+	setAttribute( e, "fontcolor", _shadowColor );
+    }
+
+
+    private void unSetBolded( boolean unbold, int cluster ) {
+	_boldedNodes = new HashSet( );
+
+	if( !unbold ) {
+	    _local = true;
+	    _bolded = (java.util.List)_localClusters.get( new Integer( cluster ) );
+	}
+
+	if( unbold ) {
+	    for( Iterator i = _bolded.iterator( ); i.hasNext( ); ) {
+
+		ElementAtt e = (ElementAtt)i.next( );
+		e.apply( );
+	    }
+	} else {
+
+	    for( int i=_bolded.size()-1; i>=0;i-- ) {
+		ElementAtt e = (ElementAtt)_bolded.get(i);
+		e.undo( );
+	    }
+	}
+
+	if( !unbold ) {
+	    _local = false;
+	} else {
+	    _localClusters.put( new Integer( cluster ), _bolded );
+	    _bolded = new ArrayList( );
+	}
+
+    }
+
+
+    private class ElementAtt {
+	private Element _e;
+	private String _att;
+	private String _value;
+	private Object _undoValue;
+
+	public ElementAtt( Element e, String att, String value, String undoValue ) {
+	    _e = e;
+	    _att = att;
+	    _value = value;
+	    _undoValue = undoValue;
+	}
+
+	public void apply( ) {
+	    _undoValue = setAttribute( _e,  _att, _value );
+	}
+
+	public void undo( ) {
+	    _e.setAttribute( _att, _undoValue );
+	}
+
+
+    }
+
+
+
+
+
+    private Object setAttribute( Element e, String attr, Object value ) {
+	Object previousValue = e.setAttribute( attr, value );
+	if( _batchUpdate != null ) {
+	    _batchUpdate.add( new ElementAttribute( e, attr, value, previousValue ) );
+	}
+
+	return previousValue;
+    }
+
+
+
+    private void setNodeProps( Node n, String prefix, boolean setBold ) {
+
+	for( int i=0; i < NODE_ATTRS.length; i++ ) {
+	    String strValue = _properties.getProperty( prefix + NODE_ATTRS_PROP[i] );
+	    if( strValue == null ) {
+		continue;
+	    }
+
+
+	    if( NODE_ATTRS_INT[i] ) {
+		setAttribute( n, NODE_ATTRS[i], new Integer( strValue ) );
+	    } else {
+		
+		if( NODE_ATTRS[i].equals( FONTSTYLE_ATTR ) && ( setBold || _boldedNodes.contains( n ) ) ) {
+		    _bolded.add( new ElementAtt( n, FONTSTYLE_ATTR, strValue,"bold" ) );
+		    strValue = "bold";
+		} 
+
+		setAttribute( n, NODE_ATTRS[i], strValue );
+
+	    }
+	}
+    }
+
+
+
+    private void setEdgeProps( Edge e, String prefix, boolean local ) {
+	for( int i=0; i < EDGE_ATTRS.length; i++ ) {
+	    String strValue = _properties.getProperty( prefix + EDGE_ATTRS_PROP[i] );
+	    String undoValue = _properties.getProperty( prefix + EDGE_ATTRS_PROP[i] + ".bold" );
+
+	    String change = strValue;
+
+
+	    if( strValue == null ) {
+		continue;
+	    }
+	    
+	    if( local ) {
+		if( undoValue != null ) {
+		    _bolded.add( new ElementAtt( e, EDGE_ATTRS[i], strValue, undoValue ) );
+		    change = undoValue;
+		}
+
+	    }
+	    
+	    setAttribute( e, EDGE_ATTRS[i], change );
+	}
+    }
+
+    
+    public void setNodeProperties( Node n, NodeState ns, boolean local, boolean newNode ) {
+	if( ns.getHidden( ) ) {
+
+	    if( _local == false ) {
+		setShadow( n );
+	    } else {
+		setInvis( n );
+	    }
+	    return;
+	}
+
+	if( ns.getBolded( ) == false && ( local && newNode ) ) {
+	    ns.setBolded( true );
+	}
+
+	if( local&&newNode ) {
+	    _boldedNodes.add( n );
+	}
+
+	setNodeProperties( n, ns.getType( ), ns.getSatisfied( ), ns.getProcessed( ), local&&newNode );
+    }
+
+
+    private void setNodeProperties( Node n, String type, String satisfaction, String process, boolean setBold ) {
+	setNodeProps( n, DEFAULT_NODE, setBold );
+	setNodeProps( n, SYSTEM_PREFIX + "node." + type + ".", setBold );
+
+	if( _basicProps ) {
+	    return;
+	}
+
+
+	setNodeProps( n, SYSTEM_PREFIX + "node.satisfied." + satisfaction + ".", setBold );
+
+	if( !_ignoreProcessing ) {
+	    setNodeProps( n, SYSTEM_PREFIX + "node.processed." + process + ".", setBold );
+	}
+    }
+
+    public void setEdgeProperties( Edge e, String type, boolean local ) {
+	setEdgeProps( e, DEFAULT_EDGE, local );
+	setEdgeProps( e, SYSTEM_PREFIX + "edge." + type + ".", local );
+    }
+
+
+    private void formatGraph( Graph g ) {
+	try {
+	    Process formater = Runtime.getRuntime( ).exec( "dot" );
+	    GrappaSupport.filterGraph( g, formater );
+	    formater.destroy( );
+	    
+	    g.repaint( );
+	} catch( Exception e ) {
+	    e.printStackTrace( );
+	}
+    }
+
+
+    public void hideGraph( ) {
+
+	hideSubgraph( _graph );
+	_graph.resync( );
+	_graph.repaint( );
+	_credentialPanel.removeRemoteCreds( );
+    }
+
+
+    public void updateGraph( ) {
+	_graph.resync( );
+	_graph.repaint( );
+    }
+
+
+    public void hideGraph( Graph g) {
+	_credentialPanel.removeRemoteCreds( );
+
+	hideSubgraph( g );
+
+	for( Iterator i = _nodeStates.values( ).iterator( ); i.hasNext( ); ) {
+	    NodeState ns = (NodeState) i.next( );
+	    ns.clearState( );
+	}
+
+	g.resync( );
+	g.repaint( );
+
+    }
+
+    private void hideSubgraph( Subgraph sg ) {
+// 	System.out.println( "HIDING GRAPH" );
+
+	Enumeration nodes = sg.nodeElements( );
+	Enumeration edges = sg.edgeElements( );
+
+	while( nodes.hasMoreElements( ) ) {
+	    Node n = (Node) nodes.nextElement( );
+	    setInvis( n );
+	}
+
+	while( edges.hasMoreElements( ) ) {
+	    Edge e = (Edge) edges.nextElement( );
+	    setInvis( e );
+	}
+    }
+
+
+    public void setInvis( Element e ) {
+	e.setAttribute( FONTSTYLE_ATTR, "normal" );
+ 	e.setAttribute( STYLE_ATTR, "invis" );
+    }
+
+    public void setLocal( boolean local ) {
+	_local = local;
+    }
+
+    public boolean getLocal( ) {
+	return _local;
+    }
+
+
+
+}
