View Javadoc
   package com.bonevich.erj.xml;
   
   import org.tigris.gef.base.Diagram;
   import org.tigris.gef.presentation.*;
   
   import javax.xml.parsers.SAXParserFactory;
   import javax.xml.parsers.SAXParser;
   import org.xml.sax.Attributes;
   import org.xml.sax.InputSource;
  import org.xml.sax.helpers.DefaultHandler;
  
  import java.io.*;
  import java.util.HashMap;
  import java.util.StringTokenizer;
  import java.awt.Color;
  import java.net.URL;
  
  public class SVGReader extends DefaultHandler
  {
  	////////////////////////////////////////////////////////////////
  	// Static variables
  	private static SVGReader _instance = new SVGReader();
  	private static String[]  _entityPaths = { "/com/bonevich/erj/xml/dtd/" };
  
  	////////////////////////////////////////////////////////////////
  	// Instance variables
  	protected Diagram _diagram = null;
  	protected HashMap _figRegistry = null;
  	protected HashMap _ownerRegistry = new HashMap();
  	protected int     _nestedGroups = 0;
  
  	////////////////////////////////////////////////////////////////
  	// XML element handler states
  	private int _elementState = 0;
  	private static final int DEFAULT_STATE = 0;
  	private static final int TEXT_STATE = 1;
  	private static final int LINE_STATE = 2;
  	private static final int POLY_STATE = 3;
  	private static final int NODE_STATE = 4;
  	private static final int EDGE_STATE = 5;
  	private static final int PRIVATE_STATE = 6;
  
  	private static final int PRIVATE_NODE_STATE = 64;
  	private static final int PRIVATE_EDGE_STATE = 65;
  	private static final int TEXT_NODE_STATE = 14;
  	private static final int TEXT_EDGE_STATE = 15;
  
  	private int _x1Int = 0;
  	private int _y1Int = 0;
  	private StringBuffer _textBuf = null;
  	private FigLine _currentLine = null;
  	private FigText _currentText = null;
  	private FigPoly _currentPoly = null;
  	private FigNode _currentNode = null;
  	private FigEdge _currentEdge = null;
  
  	////////////////////////////////////////////////////////////////
    // Constructors
  	/***
  	 * We are a Singleton Pattern, so the default constructor is
  	 * not publicly available.
  	 */
  	protected SVGReader() { }
  
  	/***
  	 * Singleton instance accessor.
  	 */
  	public static SVGReader getInstance()
  	{
  		return _instance;
  	}
  
  	/***
  	 * Initialize the mapping of Fig owner Ids to Fig owner instances.
  	 */
  	public void setOwnerRegistry(HashMap owners)
  	{
  		_ownerRegistry = owners;
  	}
  
  
  	////////////////////////////////////////////////////////////////
  	// Main parsing access operations
  
  	/***
  	 * Read a diagram given an InputStream on the SVG source.
  	 * Note: does not close the stream after reading.
  	 */
  	public synchronized Diagram readDiagram(InputStream is)
  		throws IOException
  	{
  		return readDiagram(new InputSource(is));
  	}
  
  	/***
  	 * Read a diagram given an SVG InputSource.
  	 */
  	public synchronized Diagram readDiagram(InputSource source)
  		throws IOException
 	{
 		try
 		{
 			System.out.println("======================================================");
 			System.out.println("== READING DIAGRAM: " + source.getSystemId());
 			System.out.println();
 
 			initDiagram("com.bonevich.erj.diagram.ERDiagram");
 			_figRegistry = new HashMap();
 
 			SAXParserFactory factory = SAXParserFactory.newInstance();
 			factory.setNamespaceAware(false);
 			factory.setValidating(false);
 			SAXParser pc = factory.newSAXParser();
 			pc.parse(source, this);
 			return _diagram;
 		}
 		catch (Exception e)
 		{
 			e.printStackTrace();
 			throw new IOException("Failed to load project diagram: " + e);
 		}
 	}
 
 	/***
 	 * Read a diagram given an URL to an SVG source.
 	 */
 	public synchronized Diagram readDiagram(URL url)
 		throws IOException
 	{
 		InputStream is = url.openStream();
 		InputSource source = new InputSource(is);
 		source.setSystemId(url.toString());
 
 		readDiagram(source);
 
 		source = null;
 		is.close();
 		return _diagram;
 	}
 
 	/***
 	 * Instantiate and initialize a diagram given a descriptor.
 	 * The descriptor is of the form "{{diagramClassName}}[|{{ownerInstanceId}}]"
 	 */
 	protected void initDiagram(String descriptor)
 	{
 		String className = descriptor;
 		String initStr = null;
 		int pipe = descriptor.indexOf(PIPE_STR);
 		if (pipe != -1)
 		{
 			className = descriptor.substring(0, pipe);
 			initStr = descriptor.substring(pipe + 1);
 		}
 
 		String newClassName = translateClassName(className);
 		try
 		{
 			Class cls = Class.forName(newClassName);
 			_diagram = (Diagram) cls.newInstance();
 
 			if (initStr != null && !initStr.equals(EMPTY_STR))
 			{
 				_diagram.initialize(findOwner(initStr));
 			}
 		}
 		catch (Exception ex)
 		{
 			System.out.println("Could not set diagram type to " + newClassName);
 			ex.printStackTrace();
 		}
 	}
 
 
 	//////////////////////////////////////////////////////////
 	// SAX2 ContentHandler implementation
 
 	public void startElement(String namespace,
 													 String localName,
 													 String qualifiedName,
 													 Attributes attrs)
 	{
 		switch(_elementState)
 		{
 			case DEFAULT_STATE:
 				if (qualifiedName.equals(ELEMENT_GROUP_STR))
 				{
 					_nestedGroups++;
 					_diagram.add(handleGroup(attrs));
 				}
 				else if (qualifiedName.equals(ELEMENT_SVG_STR))
 				{
 					handleSVG(attrs);
 				}
 				else if (_nestedGroups == 0)
 				{
 					if (qualifiedName.equals(ELEMENT_PATH_STR))
 					{
 						_diagram.add(handlePolyLine(attrs));
 					}
 					else if (qualifiedName.equals(ELEMENT_ELLIPSE_STR))
 					{
 						_diagram.add(handleEllipse(attrs));
 					}
 					else if (qualifiedName.equals(ELEMENT_RECT_STR))
 					{
 						_diagram.add(handleRect(attrs));
 					}
 					else if (qualifiedName.equals(ELEMENT_TEXT_STR))
 					{
 						_elementState = TEXT_STATE;
 						_diagram.add(handleText(attrs));
 					}
 					else if (qualifiedName.equals(ELEMENT_LINE_STR))
 					{
 						_diagram.add(handleLine(attrs));
 					}
 					else
 					{
 						System.out.println("Unknown top-level tag: " + qualifiedName);
 					}
 				}
 				else if (_nestedGroups > 0)
 				{
 					//System.out.println("Skipping nested " + qualifiedName);
 				}
 				break;
 
 			case LINE_STATE:
 				lineStateStartElement(qualifiedName, attrs);
 				break;
 
 			case POLY_STATE:
 				polyStateStartElement(qualifiedName, attrs);
 				break;
 
 			case NODE_STATE:
 			nodeStateStartElement(qualifiedName, attrs);
 			break;
 
 			case EDGE_STATE:
 				edgeStateStartElement(qualifiedName, attrs);
 				break;
 		}
 	}
 
 	public void characters(char[] ch, int start, int length)
 	{
 		if(_textBuf != null && 
 			 (_elementState == TEXT_STATE || _elementState == PRIVATE_STATE ||
 			  _elementState == TEXT_NODE_STATE || _elementState == TEXT_EDGE_STATE ||
 			  _elementState == PRIVATE_NODE_STATE || _elementState == PRIVATE_EDGE_STATE)
 			)
 		{
 			_textBuf.append(ch, start, length);
 		}
 	}
 
 	public void endElement(String namespace, String localName, String qualifiedName)
 	{
 		//System.err.println("(endElement) namespace = " + namespace + " and qualifiedName = " + qualifiedName);
 		switch(_elementState)
 		{
 			case 0:
 				if (qualifiedName.equals(ELEMENT_GROUP_STR))
 				{
 					_nestedGroups--;
 				}
 				break;
 
 			case POLY_STATE:
 				if(qualifiedName.equals(ELEMENT_PATH_STR))
 				{
 					_elementState = DEFAULT_STATE;
 					_currentPoly = null;
 				}
 				break;
 
 			case LINE_STATE:
 				if(qualifiedName.equals(ELEMENT_LINE_STR))
 				{
 					_elementState = DEFAULT_STATE;
 					_currentLine = null;
 				}
 				break;
 
 			case TEXT_STATE:
 				if(qualifiedName.equals(ELEMENT_TEXT_STR))
 				{
 				_currentText.setText(_textBuf.toString());
 				_elementState = DEFAULT_STATE;
 				_currentText = null;
 				_textBuf = null;
 				}
 				break;
 
 			case TEXT_NODE_STATE:
 				if(qualifiedName.equals(ELEMENT_TEXT_STR))
 				{
 					_currentText.setText(_textBuf.toString());
 					_elementState = NODE_STATE;
 					_currentText = null;
 					_textBuf = null;
 				}
 				break;
 
 			case TEXT_EDGE_STATE:
 				if(qualifiedName.equals(ELEMENT_TEXT_STR))
 				{
 					_currentText.setText(_textBuf.toString());
 					_elementState = EDGE_STATE;
 					_currentText = null;
 					_textBuf = null;
 				}
 				break;
 
 			case NODE_STATE:
 				_elementState = DEFAULT_STATE;
 				_currentNode = null;
 				_textBuf = null;
 				break;
 
 //			case EDGE_STATE:
 //				_elementState = DEFAULT_STATE;
 //				_currentEdge = null;
 //				_textBuf = null;
 //				break;
 
 			case PRIVATE_STATE:
 				privateStateEndElement(qualifiedName);
 				_textBuf = null;
 				_elementState = DEFAULT_STATE;
 				break;
 
 			case PRIVATE_NODE_STATE:
 				privateStateEndElement(qualifiedName);
 				_textBuf = null;
 				_elementState = NODE_STATE;
 				break;
 
 			case PRIVATE_EDGE_STATE:
 				privateStateEndElement(qualifiedName);
 				_textBuf = null;
 				_elementState = EDGE_STATE;
 				break;
 		}
 	}
 
 	//////////////////////////////////////////////////////////
 	// SAX2 EntityResolver implementation
 
 	public InputSource resolveEntity(String publicId, String systemId)
 	{
 		InputSource source = null;
 		try
 		{
 			URL url = new URL(systemId);
 			try
 			{
 				source = new InputSource(url.openStream());
 				source.setSystemId(systemId);
 				if (publicId != null)
 				{
 					source.setPublicId(publicId);
 				}
 			}
 			catch (IOException e)
 			{
 				if (systemId.endsWith(".dtd"))
 				{
 					int i = systemId.lastIndexOf('/');
 					i++;	// go past '/' if there, otherwise advance to 0
 					InputStream is = null;
 					for (int pathIndex = 0; pathIndex < _entityPaths.length && is == null; pathIndex++)
 					{
 						String DTD_DIR = _entityPaths[pathIndex];
 						is = getClass().getResourceAsStream(DTD_DIR + systemId.substring(i));
 						if(is == null)
 						{
 							try
 							{
 								is = new FileInputStream(DTD_DIR.substring(1) + systemId.substring(i));
 							}
 							catch(Exception ex) {}
 						}
 					}
 					if(is != null)
 					{
 						source = new InputSource(is);
 						source.setSystemId(systemId);
 						if(publicId != null)
 						{
 							source.setPublicId(publicId);
 						}
 					}
 				}
 			}
 		}
 		catch(Exception e)
 		{
 			e.printStackTrace();
 		}
 
 		//
 		//   returning an "empty" source is better than failing
 		//
 		if (source == null)
 		{
 			source = new InputSource();
 			source.setSystemId(systemId);
 		}
 		return source;
 	}
 
 
 	////////////////////////////////////////////////////////////////
 	// Internal parsing methods
 
 	protected void handleSVG(Attributes attrs)
 	{
 		String name = attrs.getValue(FIG_NAME_ATTR_STR);
 		String clsName = attrs.getValue(FIG_CLASS_ATTR_STR);
 		try
 		{
 			if (clsName != null && !clsName.equals(EMPTY_STR))
 			{
 				initDiagram(clsName);
 			}
 			if (name != null && !name.equals(EMPTY_STR))
 			{
 				_diagram.setName(name);
 			}
 		}
 		catch (Exception e)
 		{
 			e.printStackTrace();
 			System.out.println("Exception in handleSVG");
 		}
 	}
 
 	protected FigCircle handleEllipse(Attributes attrs)
 	{
 		FigCircle f = new FigCircle(0, 0, 50, 50);
 		setAttrs(f, attrs);
 
 		String cx = attrs.getValue(FIG_CENTER_X_ATTR_STR);
 		String cy = attrs.getValue(FIG_CENTER_Y_ATTR_STR);
 		String rx = attrs.getValue(FIG_RADIUS_X_ATTR_STR);
 		String ry = attrs.getValue(FIG_RADIUS_Y_ATTR_STR);
 
 		int cxInt = (cx == null || cx.equals(EMPTY_STR)) ? 0  : Integer.parseInt(cx);
 		int cyInt = (cy == null || cy.equals(EMPTY_STR)) ? 0  : Integer.parseInt(cy);
 		int rxInt = (rx == null || rx.equals(EMPTY_STR)) ? 10 : Integer.parseInt(rx);
 		int ryInt = (ry == null || ry.equals(EMPTY_STR)) ? 10 : Integer.parseInt(ry);
 
 		f.setX( cxInt - rxInt );
 		f.setY( cyInt - ryInt );
 		f.setWidth(rxInt * 2);
 		f.setHeight(ryInt * 2);
 
 		return f;
 	}
 
 	/***
 	 * Returns Fig rather than FigGroups because this is
 	 * also used for FigEdges.
 	 */
 	protected Fig handleGroup(Attributes attrs)
 	{
 		Fig f = null;
 
 		String clsNameBounds = attrs.getValue(FIG_CLASS_ATTR_STR);
 		StringTokenizer	st = new StringTokenizer(clsNameBounds, GROUP_TOKENIZER_STR);
 		String xStr = null, yStr = null, wStr = null, hStr = null;
 
 		String clsName = st.nextToken();
 		if (st.hasMoreElements())
 		{
 			xStr = st.nextToken();
 			yStr = st.nextToken();
 			wStr = st.nextToken();
 			hStr = st.nextToken();
 		}
 
 		try {
 			Class nodeClass = Class.forName(translateClassName(clsName));
 			f = (Fig) nodeClass.newInstance();
 			if (xStr != null && !xStr.equals(EMPTY_STR))
 			{
 				int x = Integer.parseInt(xStr);
 				int y = Integer.parseInt(yStr);
 				int w = Integer.parseInt(wStr);
 				int h = Integer.parseInt(hStr);
 				f.setBounds(x, y, w, h);
 			}
 
 			if (f instanceof FigNode)
 			{
 				FigNode fn    = (FigNode) f;
 				_currentNode  = fn;
 				_elementState = NODE_STATE;
 				_textBuf      = new StringBuffer();
 			}
 			else if (f instanceof FigEdge)
 			{
 				_currentEdge  = (FigEdge) f;
 				_elementState = EDGE_STATE;
 			}
 		}
 		catch (Exception e)
 		{
 			System.out.println("Exception in handleGroup");
 			e.printStackTrace();
 		}
 		catch (NoSuchMethodError e)
 		{
 			System.out.println("No default constructor for class " + clsName);
 			e.printStackTrace();
 		}
 
 		setAttrs(f, attrs);
 		return f;
 	}
 
 	protected Fig handlePolyLine(Attributes attrs)
 	{
 		String clsName = translateClassName(attrs.getValue(FIG_PATH_DESC_ATTR_STR));
 		if (clsName != null && clsName.indexOf(FIG_LINE_STR) != -1)
 		{
 			return handleLine(attrs);
 		}
 		else
 		{
 			return handlePath(attrs);
 		}
 	}
 
 	protected FigLine handleLine(Attributes attrs)
 	{
 		_currentLine = new FigLine(0, 0, 100, 100);
 		setAttrs(_currentLine, attrs);
 
 		String x1 = attrs.getValue(FIG_X1_ATTR_STR);
 		String y1 = attrs.getValue(FIG_Y1_ATTR_STR);
 		_x1Int = (x1 == null || x1.equals(EMPTY_STR)) ? 0 : Integer.parseInt(x1);
 		_y1Int = (y1 == null || y1.equals(EMPTY_STR)) ? 0 : Integer.parseInt(y1);
 		_currentLine.setX1(_x1Int);
 		_currentLine.setY1(_y1Int);
 
 		String x2 = attrs.getValue(FIG_X2_ATTR_STR);
 		String y2 = attrs.getValue(FIG_Y2_ATTR_STR);
 		int x2Int = (x2 == null || x2.equals(EMPTY_STR)) ? _x1Int : Integer.parseInt(x2);
 		int y2Int = (y2 == null || y2.equals(EMPTY_STR)) ? _y1Int : Integer.parseInt(y2);
 		_currentLine.setX2(x2Int);
 		_currentLine.setY2(y2Int);
 
 		_elementState = LINE_STATE;
 		return _currentLine;
 	}
 
 	protected FigPoly handlePath(Attributes attrs)
 	{
 		String type = attrs.getValue(FIG_CLASS_ATTR_STR);
 
 		FigPoly f = null;
 		try
 		{
 			Class pathClass = Class.forName(translateClassName(type));
 			f = (FigPoly) pathClass.newInstance();
 
 			// Set the default attributes
 			setAttrs(f, attrs);
 
 			_currentPoly = f;
 			_elementState = POLY_STATE;
 
 			// Set the path data
 			String path = attrs.getValue(FIG_PATH_DATA_ATTR_STR);
 			int	x = -1;
 			int	y = -1;
 
 			StringReader reader = new StringReader(path);
 			StreamTokenizer tokenizer = new StreamTokenizer(reader);
 
 			int tok = tokenizer.nextToken();
 			while (tok != StreamTokenizer.TT_EOF)
 			{
 				if (tok == StreamTokenizer.TT_NUMBER)
 				{
 					if (x == -1)
 					{
 						x = (int)tokenizer.nval;
 					}
 					else
 					{
 						y = (int)tokenizer.nval;
 					}
 
 					// Add the point
 					if (x != -1 && y != -1)
 					{
 						f.addPoint(x,y);
 						x = -1;
 						y = -1;
 					}
 				}
 
 				tok = tokenizer.nextToken();
 			}
 		}
 		catch (Exception e)
 		{
 			e.printStackTrace();
 		}
 
 		return f;
 	}
 
 	protected FigRect handleRect(Attributes attrs)
 	{
 		FigRect f;
 		String cornerRadius = attrs.getValue(FIG_RADIUS_X_ATTR_STR);
 		if (cornerRadius == null || cornerRadius.equals(EMPTY_STR))
 		{
 			f = new FigRect(0, 0, 80, 80);
 		}
 		else
 		{
 			f = new FigRRect(0, 0, 80, 80);
 			int rInt = Integer.parseInt(cornerRadius);
 			((FigRRect) f).setCornerRadius(rInt);
 		}
 		setAttrs(f, attrs);
 		return f;
 	}
 	
 	protected FigText handleText(Attributes attrs)
 	{
 		FigText f = new FigText(100, 100, 90, 45);
 		setAttrs(f, attrs);
 
 		_elementState = TEXT_STATE;
 		_textBuf = new StringBuffer();
 		_currentText = f;
 
 		String style = attrs.getValue(FIG_STYLE_ATTR_STR);
 		if (style != null)
 		{
 			String font = parseStyle(STYLE_FONT_STR, style);
 			if (font != null)
 			{
 				f.setFontFamily(font);
 			}
 			String size = parseStyle(STYLE_FONT_SIZE_STR, style);
 			if (size != null)
 			{
 				int s = Integer.parseInt( size );
 				f.setFontSize( s );
 			}
 		}
 		return f;
 	}
 
 	
 	////////////////////////////////////////////////////////////////
 	// Internal methods
 
 	private void nodeStateStartElement(String tagName, Attributes attrs)
 	{
 		if (tagName.equals(FIG_DESC_ATTR_STR))
 		{
 		}
 		else if (tagName.equals(FIG_TITLE_ATTR_STR))
 		{
 		}
 		else if (tagName.equals(FIG_SWITCH_ATTR_STR))
 		{
 			_textBuf = new StringBuffer();
 			_elementState = PRIVATE_NODE_STATE;
 		}
 		else if (tagName.equals(FIG_TEXT_ATTR_STR))
 		{
 			_textBuf = new StringBuffer();
 			_elementState = TEXT_NODE_STATE;
 			Fig p = handleText(attrs);
 		}
 	}
 
 	private void edgeStateStartElement(String tagName, Attributes attrs)
 	{
 		if (tagName.equals(FIG_DESC_ATTR_STR))
 		{
 		}
 		else if (tagName.equals(FIG_TITLE_ATTR_STR))
 		{
 		}
 		else if (tagName.equals(FIG_PATH_ATTR_STR))
 		{
 			Fig p = handlePath(attrs);
 			_currentEdge.setFig(p);
 			((FigPoly) p)._isComplete = true;
 			_currentEdge.calcBounds();
 			if (_currentEdge instanceof FigEdgePoly)
 			{
 				((FigEdgePoly) _currentEdge).setInitiallyLaidOut(true);
 			}
 		}
 		else if (tagName.equals(FIG_SWITCH_ATTR_STR))
 		{
 			_elementState = PRIVATE_EDGE_STATE;
 			_textBuf = new StringBuffer();
 		}
 		else if (tagName.equals(FIG_TEXT_ATTR_STR))
 		{
 			_elementState = TEXT_EDGE_STATE;
 			_textBuf = new StringBuffer();
 			Fig p = handleText(attrs);
 		}
 	}
 
 	protected void lineStateStartElement(String tagName, Attributes attrs)
 	{
 		dumpAttributes(attrs);
 		if (_currentLine != null)
 		{
 			if (tagName.equals(FIG_DESC_ATTR_STR))
 			{
 			}
 			else if (tagName.equals(FIG_TITLE_ATTR_STR))
 			{
 			}
 			else if (tagName.equals(FIG_MOVETO_ATTR_STR))
 			{
 				String x1 = attrs.getValue(FIG_X_ATTR_STR);
 				String y1 = attrs.getValue(FIG_Y_ATTR_STR);
 				_x1Int = (x1 == null || x1.equals(EMPTY_STR)) ? 0 : Integer.parseInt(x1);
 				_y1Int = (y1 == null || y1.equals(EMPTY_STR)) ? 0 : Integer.parseInt(y1);
 				_currentLine.setX1(_x1Int);
 				_currentLine.setY1(_y1Int);
 			}
 			else if (tagName.equals(FIG_LINETO_ATTR_STR))
 			{
 				String x2 = attrs.getValue(FIG_X_ATTR_STR);
 				String y2 = attrs.getValue(FIG_Y_ATTR_STR);
 				int x2Int = (x2 == null || x2.equals(EMPTY_STR)) ? _x1Int : Integer.parseInt(x2);
 				int y2Int = (y2 == null || y2.equals(EMPTY_STR)) ? _y1Int : Integer.parseInt(y2);
 				_currentLine.setX2(x2Int);
 				_currentLine.setY2(y2Int);
 			}
 		}
 	}
 
 	private void polyStateStartElement(String tagName, Attributes attrs)
 	{
 		if (_currentPoly != null)
 		{
 			if (tagName.equals(FIG_DESC_ATTR_STR))
 			{
 			}
 			else if (tagName.equals(FIG_TITLE_ATTR_STR))
 			{
 			}
 			else if (tagName.equals(FIG_MOVETO_ATTR_STR))
 			{
 				String x1 = attrs.getValue(FIG_X_ATTR_STR);
 				String y1 = attrs.getValue(FIG_Y_ATTR_STR);
 				_x1Int = (x1 == null || x1.equals(EMPTY_STR)) ? 0 : Integer.parseInt(x1);
 				_y1Int = (y1 == null || y1.equals(EMPTY_STR)) ? 0 : Integer.parseInt(y1);
 				_currentPoly.addPoint(_x1Int, _y1Int);
 			}
 			else if (tagName.equals(FIG_LINETO_ATTR_STR))
 			{
 				String x2 = attrs.getValue(FIG_X_ATTR_STR);
 				String y2 = attrs.getValue(FIG_Y_ATTR_STR);
 				int x2Int = (x2 == null || x2.equals(EMPTY_STR)) ? _x1Int : Integer.parseInt(x2);
 				int y2Int = (y2 == null || y2.equals(EMPTY_STR)) ? _y1Int : Integer.parseInt(y2);
 				_currentPoly.addPoint(x2Int, y2Int);
 			}
 		}
 	}
 
 	private void privateStateEndElement(String tagName)
 	{
 		String body = _textBuf.toString();
 
 		if (_currentNode != null)
 		{
 			if ( _currentEdge != null )
 			{
 				_currentEdge = null;
 			}
 
 			_currentNode.setPrivateData(body);
 
 			Fig encloser = null;
 			StringTokenizer st2 = new StringTokenizer(body, PRIVATE_DATA_TOKENIZER_STR);
 			while (st2.hasMoreElements())
 			{
 				String t = st2.nextToken();
 				String v = EMPTY_STR;
 				if (st2.hasMoreElements())
 				{
 					v = st2.nextToken();
 				}
 
 				if (t.equals(PRIVATE_DATA_ENC_FIG_STR))
 				{
 					encloser = findFig(v);
 				}
 				else if (t.equals(PRIVATE_DATA_TEXT_STR))
 				{
 					//do nothing
 				}
 			}
 			_currentNode.setEnclosingFig(encloser);
 		}
 
 		if (_currentEdge != null)
 		{
 			_currentEdge.setPrivateData(body);
 
 			Fig     spf = null;
 			Fig     dpf = null;
 			FigNode sfn = null;
 			FigNode dfn = null;
 
 			StringTokenizer st2 = new StringTokenizer(body, PRIVATE_DATA_TOKENIZER_STR);
 			while (st2.hasMoreElements())
 			{
 				String t = st2.nextToken();
 				String v = st2.nextToken();
 				if (t.equals(PRIVATE_DATA_SRCPORT_STR))
 				{
 					spf = findFig(v);
 				}
 				if (t.equals(PRIVATE_DATA_DESTPORT_STR))
 				{
 					dpf = findFig(v);
 				}
 				if (t.equals(PRIVATE_DATA_SRCNODE_STR))
 				{
 					sfn = (FigNode) findFig(v);
 				}
 				if (t.equals(PRIVATE_DATA_DESTNODE_STR))
 				{
 					dfn = (FigNode) findFig(v);
 				}
 			}
 
 			_currentEdge.setSourcePortFig(spf);
 			_currentEdge.setDestPortFig(dpf);
 			_currentEdge.setSourceFigNode(sfn);
 			_currentEdge.setDestFigNode(dfn);
 		}
 	}
 
 
 	//////////////////////////////////////////////////////////
 	// Utility operations
 
 	protected void setAttrs(Fig f, Attributes attrs)
 	{
 		//dumpAttributes(attrs);
 
 		String name = attrs.getValue(FIG_NAME_ATTR_STR);
 		if (name != null && !name.equals(EMPTY_STR))
 		{
 			_figRegistry.put(name, f);
 		}
 
 		String x = attrs.getValue(FIG_X_ATTR_STR);
 		if (x != null && !x.equals(EMPTY_STR))
 		{
 			String y = attrs.getValue(FIG_Y_ATTR_STR);
 			String w = attrs.getValue(FIG_WIDTH_ATTR_STR);
 			String h = attrs.getValue(FIG_HEIGHT_ATTR_STR);
 			int xInt = Integer.parseInt(x);
 			int yInt = (y == null || y.equals(EMPTY_STR)) ? 0 : Integer.parseInt(y);
 			int wInt = (w == null || w.equals(EMPTY_STR)) ? 20 : Integer.parseInt(w);
 			int hInt = (h == null || h.equals(EMPTY_STR)) ? 20 : Integer.parseInt(h);
 			f.setBounds(xInt, yInt, wInt, hInt);
 		}
 
 		// Parse Style
 		String style = attrs.getValue(FIG_STYLE_ATTR_STR);
 		if (style != null)
 		{
 			String fillcolor = parseStyle(STYLE_FILL_STR, style);
 			if (fillcolor != null && !fillcolor.equals(EMPTY_STR))
 			{
 				f.setFillColor( parseColor(fillcolor, Color.blue ) );
 			}
 
 			if (!(f instanceof FigNode))
 			{
 				String linewidth = parseStyle(STYLE_STROKE_WIDTH_STR, style);
 				if (linewidth != null && !linewidth.equals(EMPTY_STR))
 				{
 					f.setLineWidth(Integer.parseInt(linewidth));
 				}
 				String strokecolor = parseStyle(STYLE_STROKE_STR, style);
 				if (strokecolor != null && !strokecolor.equals(EMPTY_STR))
 				{
 					f.setLineColor( parseColor(strokecolor, Color.blue ) );
 				}
 
 				String dasharray = parseStyle(STYLE_STROKE_DASH_ARRAY_STR, style);
 				if (dasharray != null && !dasharray.equals(EMPTY_STR) && !dasharray.equals(SET_VALUE_STR))
 				{
 					f.setDashed(true);
 				}
 			}
 		}
 
 		String dynobjs = attrs.getValue(FIG_DYNOBJ_ATTR_STR);
 		if (dynobjs != null && dynobjs.length() != 0 && f instanceof FigGroup)
 		{
 			FigGroup fg = (FigGroup) f;
 			fg.parseDynObjects(dynobjs);
 		}
 
 		setOwnerAttr(f, attrs);
 	}
 
 	protected void setOwnerAttr(Fig f, Attributes attrs)
 	{
 		try
 		{
 			String owner = attrs.getValue(FIG_OWNER_HREF_ATTR_STR);
 			if (owner != null && !owner.equals(EMPTY_STR))
 			{
 				f.setOwner(findOwner(owner));
 			}
 		}
 		catch (Exception e)
 		{
 			e.printStackTrace();
 			System.out.println("Could not set owner");
 		}
 	}
 
 	protected Fig findFig(String uri)
 	{
 		Fig f = null;
 		if (uri.indexOf(DOT_STR) == -1)
 		{
 			f = (Fig) _figRegistry.get(uri);
 		}
 		else
 		{
 			StringTokenizer st = new StringTokenizer(uri, DOT_STR);
 			String figNum = st.nextToken();
 			f = (Fig) _figRegistry.get(figNum);
 			if (f instanceof FigEdge)
 			{
 				return ((FigEdge) f).getFig();
 			}
 
 			while (st.hasMoreElements())
 			{
 				if (f instanceof FigGroup)
 				{
 					String subIndex = st.nextToken();
 					int i = Integer.parseInt(subIndex);
 					f = (Fig)((FigGroup) f).getFigs().elementAt(i);
 				}
 			}
 		}
 		return f;
 	}
 
 	protected Object findOwner(String uri)
 	{
 		Object own = _ownerRegistry.get(uri);
 		return own;
 	}
 
 	/***
 	 * Translate a given class name into another???
 	 */
 	protected String translateClassName(String oldName)
 	{
 		return oldName;
 	}
 
 	protected Color parseColor(String name, Color defaultColor)
 	{
 		try
 		{
 			int start = name.indexOf(RGB_STR, 0);
 			if (start != -1)
 			{
 				start = name.indexOf(OPAREN_STR, start);
 				int end = name.indexOf(COMMA_STR, start);
 				if (start != -1)
 				{
 					start++;
 					int red   = Integer.parseInt(name.substring( start, end ).trim());
 					start     = end + 1;
 					end       = name.indexOf(COMMA_STR, start);
 					int green = Integer.parseInt(name.substring( start, end ).trim());
 					start     = end + 1;
 					end       = name.indexOf(CPAREN_STR, start);
 					int blue  = Integer.parseInt(name.substring( start, end ).trim());
 					return new Color(red, green, blue);
 				}
 				return defaultColor;
 			}
 		}
 		catch (Exception ex)
 		{
 			System.out.println("Invalid rgb() sequence: " + name);
 			return defaultColor;
 		}
 
 		return colorByName(name, defaultColor);
 	}
 
 	protected Color colorByName(String name, Color defaultColor)
 	{
 		if (name.equalsIgnoreCase(NONE_STR))      return null;
 		if (name.equalsIgnoreCase(WHITE_STR))     return Color.white;
 		if (name.equalsIgnoreCase(LIGHTGRAY_STR)) return Color.lightGray;
 		if (name.equalsIgnoreCase(GRAY_STR))      return Color.gray;
 		if (name.equalsIgnoreCase(DARKGRAY_STR))  return Color.darkGray;
 		if (name.equalsIgnoreCase(BLACK_STR))     return Color.black;
 		if (name.equalsIgnoreCase(RED_STR))       return Color.red;
 		if (name.equalsIgnoreCase(PINK_STR))      return Color.pink;
 		if (name.equalsIgnoreCase(ORANGE_STR))    return Color.orange;
 		if (name.equalsIgnoreCase(YELLOW_STR))    return Color.yellow;
 		if (name.equalsIgnoreCase(GREEN_STR))     return Color.green;
 		if (name.equalsIgnoreCase(MAGENTA_STR))   return Color.magenta;
 		if (name.equalsIgnoreCase(CYAN_STR))      return Color.cyan;
 		if (name.equalsIgnoreCase(BLUE_STR))      return Color.blue;
 		try
 		{
 			return Color.decode(name);
 		}
 		catch (Exception e)
 		{
 			System.out.println("Invalid color code string: " + name);
 		}
 		return defaultColor;
 	}
 
 	/***
 	* This method parses the 'style' attribute for a particular field
 	* @return java.lang.String
 	* @param field java.lang.String
 	* @param style java.lang.String
 	*/
 	protected String parseStyle(String field, String style)
 	{
 		field += COLON_STR;
 		int start = style.indexOf(field, 0);
 		if ( start != -1 )
 		{
 			int end = style.indexOf(SEMICOLON_STR, start);
 			if ( end != -1 )
 			{
 				return style.substring( start + field.length(), end ).trim();
 			}
 			else
 			{
 				return style.substring( start + field.length(), style.length() - 1 ).trim();
 			}
 		}
 		return null;
 	}
 
 	private void dumpAttributes(Attributes attrs)
 	{
 		int num = attrs.getLength();
 		for (int i = 0; i < num; i++)
 		{
 			System.err.println("attr: lname = " + attrs.getLocalName(i) +
 												 "; qname = " + attrs.getQName(i) +
 												 "; type = " + attrs.getType(i) +
 												 "; uri = " + attrs.getURI(i) +
 												 "; value = " + attrs.getValue(i)
 												);
 		}
 	}
 
 	//////////////////////////////////////////////////////////
 	// Useful Parsing Constants
 	private static final String EMPTY_STR = "";
 	private static final String PIPE_STR = "|";
 	private static final String DOT_STR = ".";
 	private static final String COLON_STR = ":";
 	private static final String SEMICOLON_STR = ";";
 	private static final String COMMA_STR = ",";
 	private static final String OPAREN_STR = "(";
 	private static final String CPAREN_STR = ")";
 	private static final String RGB_STR = "rgb";
 	private static final String GROUP_TOKENIZER_STR = ",;[] ";
 	private static final String PRIVATE_DATA_TOKENIZER_STR = "=\"' \t\n";
 	private static final String PRIVATE_DATA_ENC_FIG_STR = "enclosingFig";
 	private static final String PRIVATE_DATA_TEXT_STR = "text";
 	private static final String PRIVATE_DATA_SRCPORT_STR = "sourcePortFig";
 	private static final String PRIVATE_DATA_DESTPORT_STR = "destPortFig";
 	private static final String PRIVATE_DATA_SRCNODE_STR = "sourceFigNode";
 	private static final String PRIVATE_DATA_DESTNODE_STR = "destFigNode";
 
 	private static final String ELEMENT_SVG_STR = "svg";
 	private static final String ELEMENT_PATH_STR = "path";
 	private static final String ELEMENT_ELLIPSE_STR = "ellipse";
 	private static final String ELEMENT_RECT_STR = "rect";
 	private static final String ELEMENT_TEXT_STR = "text";
 	private static final String ELEMENT_LINE_STR = "line";
 	private static final String ELEMENT_GROUP_STR = "g";
 
 	private static final String FIG_NAME_ATTR_STR = "id";
 	private static final String FIG_CLASS_ATTR_STR = "class";
 	private static final String FIG_DESC_ATTR_STR = "desc";
 	private static final String FIG_TITLE_ATTR_STR = "title";
 	private static final String FIG_SWITCH_ATTR_STR = "switch";
 	private static final String FIG_TEXT_ATTR_STR = "text";
 	private static final String FIG_PATH_ATTR_STR = "path";
 	private static final String FIG_MOVETO_ATTR_STR = "moveto";
 	private static final String FIG_LINETO_ATTR_STR = "lineto";
 	private static final String FIG_OWNER_HREF_ATTR_STR = "gef:href";
 	private static final String FIG_X_ATTR_STR = "x";
 	private static final String FIG_Y_ATTR_STR = "y";
 	private static final String FIG_X1_ATTR_STR = "x1";
 	private static final String FIG_Y1_ATTR_STR = "y1";
 	private static final String FIG_X2_ATTR_STR = "x2";
 	private static final String FIG_Y2_ATTR_STR = "y2";
 	private static final String FIG_WIDTH_ATTR_STR = "width";
 	private static final String FIG_HEIGHT_ATTR_STR = "height";
 	private static final String FIG_STYLE_ATTR_STR = "style";
 	private static final String FIG_DYNOBJ_ATTR_STR = "dynobjects";
 	private static final String FIG_CENTER_X_ATTR_STR = "cx";
 	private static final String FIG_CENTER_Y_ATTR_STR = "cy";
 	private static final String FIG_RADIUS_X_ATTR_STR = "rx";
 	private static final String FIG_RADIUS_Y_ATTR_STR = "ry";
 	private static final String FIG_PATH_DATA_ATTR_STR = "d";
 	private static final String FIG_PATH_DESC_ATTR_STR = "description";
 
 	private static final String STYLE_FILL_STR = "fill";
 	private static final String STYLE_FONT_STR = "font";
 	private static final String STYLE_FONT_SIZE_STR = "font-size";
 	private static final String STYLE_STROKE_STR = "stroke";
 	private static final String STYLE_STROKE_WIDTH_STR = "stroke-width";
 	private static final String STYLE_STROKE_DASH_ARRAY_STR = "stroke-dash-array";
 	private static final String SET_VALUE_STR = "1";
 	private static final String FIG_LINE_STR = "FigLine";
 
 	private static final String NONE_STR = "none";
 	private static final String WHITE_STR = "white";
 	private static final String LIGHTGRAY_STR = "lightGray";
 	private static final String GRAY_STR = "gray";
 	private static final String DARKGRAY_STR = "darkGray";
 	private static final String BLACK_STR = "black";
 	private static final String RED_STR = "red";
 	private static final String PINK_STR = "pink";
 	private static final String ORANGE_STR = "orange";
 	private static final String YELLOW_STR = "yellow";
 	private static final String GREEN_STR = "green";
 	private static final String MAGENTA_STR = "magenta";
 	private static final String CYAN_STR = "cyan";
 	private static final String BLUE_STR = "blue";
 
 } /* end class SVGReader */