graphencoder.java

JGraph扩展应用。自定义Renderer,自定义视图View实现自定义工作流控件

	     + encodeFont(GraphConstants.getFont(attributes), "Font", level)
	     + encodeColor(GraphConstants.getLineColor(attributes), "BorderColor",level)
	     + encodeIcon(GraphConstants.getIcon(attributes), "Icon", level)
	     //+ encodeBoolean(GraphConstants.getOpaque(attributes), "Opaque", level)
	     + encodeBean(GraphConstants.getValue(attributes), "Value", level)
	     + "\t</node>";
	 //System.out.println(encoded);
	 //System.out.println(GPCellViewFactory.getViewClass(attributes));
	 System.out.println(attributes);
	 try {
		 Vector v = new Vector();
		 v.add(label);
		 v.add(attributes);
		 XMLEncoder enc = new XMLEncoder(new BufferedOutputStream(new FileOutputStream("D:/tmp/kuangzy2.xml")));
		 enc.writeObject(v);
		 enc.close();
	 } catch (FileNotFoundException e) {
		 // TODO Auto-generated catch block
		 e.printStackTrace();
	 }
		
	 return encoded;
	}

	protected static String encodeIcon(Icon icon, String attributeName, int level) {
	 if (icon != null) {
	   String tab1 = createTab(level + 1);
	   int level2 = level + 2;
	   String values = tab1 + "<tup>\n" +
	       encodeValue(icon.toString(), level2) +
	       tab1 + "</tup>\n";
	   return encodeAttribute(values, attributeName, level);
	 }
	 else { // 为了避免在没有GIF文件的时候,还原图的时候循环退出,给出一个空GIF文件
	   // 就是DEFAULT的图片..
	   String tab1 = createTab(level + 1);
	   int level2 = level + 2;
	   String values = tab1 + "<tup>\n" +
	       encodeValue("", level2) +
	       tab1 + "</tup>\n";

	   return encodeAttribute(values, attributeName, level);
	 }
	}

	/**
	* Encode a Edge of a graph
	*
	* @param graph Graph containing the edge.
	* @param id Id of the vertex.
	* @param vertex Edge to be encoded.
	* @return Encoded string.
	*/
	protected static String encodeEdge(JGraph graph, Object id, Object edge) {
	 GraphModel model = graph.getModel();
	 String from = "";
	 if (model.getSource(edge) != null) {
	   Object source = encodeHash.get(model.getParent(model.getSource(edge)));
	   if (source != null) {
	     from = source.toString();
	   }
	 }
	 String to = "";
	 if (model.getTarget(edge) != null) {
	   Object target = encodeHash.get(model.getParent(model.getTarget(edge)));
	   if (target != null) {
	     to = target.toString();
	   }
	 }
	 if (from != null && to != null) {
	   int level = 2;
	   Map attributes = ( (GraphCell) edge).getAttributes();
	   String label = graph.convertValueToString(edge);
	   return "\n\t<edge id=\"edge"
	       + id.toString()
	       + "\""
	       + " from=\""
	       + from
	       + "\""
	       + " to=\""
	       + to
	       + "\">\n"
	       + encodeString(label, "Label", 2)
	       +
	       encodeInteger(GraphConstants.getLineEnd(attributes), "LineEnd", level)
	       +
	       encodeColor(GraphConstants.getForeground(attributes), "Foreground",
	                   level)
	       + encodeFont(GraphConstants.getFont(attributes), "Font", level)
	       +
	       encodeInteger(GraphConstants.getLineStyle(attributes), "LineStyle",
	                     level)
	       +
	       encodeColor(GraphConstants.getLineColor(attributes), "LineColor",
	                   level)
	       + "\n\t</edge>";
	 }
	 else {
	   return "";
	 }
	}

	/**
	* Extracts visual properties of the node from the child 'view' element
	* Currently recognized properties:
	* - Bounds
	* - color
	* - background-color
	* - autosize
	* - Font
	* - Line-End, Line-size, Line-color
	*/
	protected static void decodeCell(Node gnode, Map gnode_attrs) {
	 NodeList gnode_children = gnode.getChildNodes();
	 for (int gnode_child_i = 0; gnode_child_i < gnode_children.getLength();
	      gnode_child_i++) {
	   Node gnode_child = gnode_children.item(gnode_child_i);
	   if (gnode_child.getNodeName().equals("attr")) {
	     String name = ( (Element) gnode_child).getAttribute("name");
	     LinkedList values = new LinkedList();
	     // Retreaving all the values in the node
	     readGXLAttributeValues(gnode_child, values);
	     if ( (name != null) && (values.size() > 0)) {
	       if (name.equals("Bounds")) {
	         if (values.size() == 4) {
	           Point p = new Point(Integer.parseInt( (String) values.get(0)),
	                               Integer.parseInt( (String) values.get(1)));
	           Dimension d = new Dimension(Integer.parseInt( (String) values.get(
	               2)),
	                                       Integer.parseInt( (String) values.get(
	               3)));
	           Rectangle2D bounds = new Rectangle(p, d);
	           GraphConstants.setBounds(gnode_attrs, bounds);
	         }
	       }
	       else if (name.equals("Font")) {
	         if (values.size() == 3) {
	           Font font = new Font( (String) values.get(0),
	                                Integer.parseInt( (String) values.get(1)),
	                                Integer.parseInt( (String) values.get(2)));
	           GraphConstants.setFont(gnode_attrs, font);
	         }
	       }
	       else if (name.equals("Foreground")) {
	         try {
	           Color color = new Color(Integer.parseInt( (String) values.get(0)),
	                                   Integer.parseInt( (String) values.get(1)),
	                                   Integer.parseInt( (String) values.get(2)));
	           GraphConstants.setForeground(gnode_attrs, color);
	         }
	         catch (Exception nfe) {
	         }
	       }
	       else if (name.equals("BorderColor")) {
	         try {
	           Color color = new Color(Integer.parseInt( (String) values.get(0)),
	                                   Integer.parseInt( (String) values.get(1)),
	                                   Integer.parseInt( (String) values.get(2)));
	           GraphConstants.setBorderColor(gnode_attrs, color);
	         }
	         catch (Exception nfe) {
	         }
	       }
	       else if (name.equals("LineColor")) {
	         try {
	           Color color = new Color(Integer.parseInt( (String) values.get(0)),
	                                   Integer.parseInt( (String) values.get(1)),
	                                   Integer.parseInt( (String) values.get(2)));
	           GraphConstants.setLineColor(gnode_attrs, color);
	         }
	         catch (Exception nfe) {
	         }
	       }
	       else if (name.equals("Background")) {
	         try {
	           Color color = new Color(Integer.parseInt( (String) values.get(0)),
	                                   Integer.parseInt( (String) values.get(1)),
	                                   Integer.parseInt( (String) values.get(2)));
	           GraphConstants.setBackground(gnode_attrs, color);
	         }
	         catch (Exception nfe) {
	         }
	       }
	       else if (name.equals("LineColor")) {
	         try {
	           Color color = new Color(Integer.parseInt( (String) values.get(0)),
	                                   Integer.parseInt( (String) values.get(1)),
	                                   Integer.parseInt( (String) values.get(2)));
	           GraphConstants.setLineColor(gnode_attrs, color);
	         }
	         catch (Exception nfe) {
	         }
	       }
	       else if (name.equals("LineEnd")) {
	         try {
	           GraphConstants.setLineEnd(gnode_attrs,
	                                     Integer.parseInt( (String) values.get(0)));
	         }
	         catch (Exception e) {}
	       }
	       else if (name.equals("LineStyle")) {
	         try {
	           GraphConstants.setLineStyle(gnode_attrs,
	                                       Integer.parseInt( (String) values.get(
	               0)));
	         }
	         catch (Exception e) {}
	       }
	       else if (name.equals("AutoSize")) {
	         GraphConstants.setAutoSize(gnode_attrs,
	                                    "true".equals( (String) values.get(0)));
	       }
	     }
	   }
	 }
	}

	/**
	* Reads the values of an GXL Attribute.
	*
	* @param enode Node to read.
	* @param linkedList List to populate : with 2 dimension String arrys.
	*                              return[0] : type of value
	*                              return[1] : value
	*/
	protected static void readGXLAttributeValues(Node enode, LinkedList values) {
	 // read Child Elements
	 NodeList child_list = enode.getChildNodes();
	 for (int j = 0; j < child_list.getLength(); j++) {
	   Node currentNode = child_list.item(j);
	   String nodeName = currentNode.getNodeName();
	   if (nodeName.equals("tup") ||
	       nodeName.equals("set") ||
	       nodeName.equals("enum") ||
	       nodeName.equals("seq") ||
	       nodeName.equals("bag")) {
	     readGXLAttributeValues(currentNode, values);
	   }
	   else if (nodeName.equals("int") ||
	            nodeName.equals("bool") ||
	            nodeName.equals("float") ||
	            nodeName.equals("string") ||
	            nodeName.equals("locator")) {
	     try {
	       values.add(currentNode.getFirstChild().getNodeValue());
	     }
	     catch (DOMException e) {}
	   }
	 }
	}

	/**
	* Decodes a Edge.
	*
	* @param enode XML Node.
	* @param enode_attrs Cell Attributes.
	*/
	protected static void decodeEdge(Node enode, Map enode_attrs) {
	 decodeCell(enode, enode_attrs);
	}

	/**
	* Decodes a GXL File.
	*
	* @param inputStream Stream to be decoded.
	* @param graph Graph where the decode file is inserted.
	*/
	public static void decode(InputStream inputStream,JGraph graph) throws Exception {
	 String defaultLayout = null;
	 GraphModel model = graph.getModel();
	 // Create a DocumentBuilderFactory
	 DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
	 // Create a DocumentBuilder
	 DocumentBuilder db = dbf.newDocumentBuilder();
	 // Parse the input file to get a Document object
	 Document doc = db.parse(inputStream);
	 // Get the first child (the graph-element)
	 // List for the new Cells
	 List newCells = new ArrayList();
	 // ConnectionSet for the Insert method
	 ConnectionSet cs = new ConnectionSet();
	 // Hashtable for the ID lookup (ID to Vertex)
	 decodeHash = new Hashtable();
	 // Hashtable for Attributes (Vertex to Map)
	 Hashtable attributes = new Hashtable();

	 Element gxl = (Element) doc.getDocumentElement(); // First gxl element

	 NodeList graph_list = gxl.getChildNodes();
	 if (graph_list.getLength() == 0) {
	   return;
	 }
	 for (int graph_index = 0; graph_index < graph_list.getLength(); graph_index++) {
	   Node graph_node = graph_list.item(graph_index);
	   if (graph_node.getNodeName().equals("graph")) {
	     Element graph_elem = (Element) graph_node;
	     NodeList list = graph_elem.getChildNodes();
	     boolean defaultDirected = "directed".equals(graph_elem.getAttribute(
	         "edgemode")) ||
	         "defaultdirected".equals(graph_elem.getAttribute("edgemode"));
	     // End of Opheamro

	     // Get Graph's Child Nodes (the cells)


	     // Loop Children
	     for (int i = 0; i < list.getLength(); i++) {
	       Node node = list.item(i);
	       // Fetch Label
	       String label = getLabel(node);
	       // If Valid Node
	       if (node.getAttributes() != null && node.getNodeName() != null) {
	         // Fetch Type
	         String type = node.getNodeName().toString().toLowerCase();

	         // Create Vertex
	         if (type.equals("node")) {
	           // Fetch ID Node
	           String id = null;
	           Node tmp = node.getAttributes().getNamedItem("id");
	           // Fetch ID Value
	           if (tmp != null) {
	             id = tmp.getNodeValue();
	             // Need unique valid ID
	           }
	           if (id != null && !decodeHash.keySet().contains(id)) {
	             // Create Vertex with label
	             DefaultGraphCell vertex = new DefaultGraphCell(label);
	             // Add One Floating Port
	             vertex.add(new DefaultPort());
	             // Add ID, Vertex pair to Hashtable
	             decodeHash.put(id, vertex);
	             // Add Default Attributes
	             Map node_attrs = new Hashtable(); //createDefaultAttributes(new Hashtable());
	             decodeCell(node, node_attrs);
	             attributes.put(vertex, node_attrs);
	             // Add Vertex to new Cells
	             newCells.add(vertex);
	           }

	           // Create Edge
	         }
	         else if (type.equals("edge")) {
	           Element edge_node = (Element) node;
	           // Fetch Source ID Node
	           Node tmp = node.getAttributes().getNamedItem("from");
	           // Fetch Source ID Value
	           String source = null;
	           if (tmp != null) {
	             source = tmp.getNodeValue();
	             // Fetch Target ID Node
	           }
	           tmp = node.getAttributes().getNamedItem("to");
	           // Fetch Target ID Value
	           String target = null;
	           if (tmp != null) {
	             target = tmp.getNodeValue();
	             // Create Edge with label
	           }
	           DefaultEdge edge = new DefaultEdge(label);
	           // Find Source Port
	           if (source != null) {
	             // Fetch Vertex for Source ID
	             DefaultGraphCell vertex =
	                 (DefaultGraphCell) decodeHash.get(source);
	             if (vertex != null) {

	               // Connect to Source Port
	               cs.connect(edge, vertex.getChildAt(0), true);
	             }
	           }
	           // Find Target Port
	           if (target != null) {
	             // Fetch Vertex for Target ID
	             DefaultGraphCell vertex =
	                 (DefaultGraphCell) decodeHash.get(target);
	             if (vertex != null) {

	               // Connect to Target Port
	               cs.connect(edge, vertex.getChildAt(0), false);
	             }
	           }

	           boolean edge_directed = ("true".equals(edge_node.getAttribute(
	               "isdirected")) || defaultDirected)
	               && ! ("false".equals(edge_node.getAttribute("isdirected")));
	           Map map = new Hashtable();
	           if (edge_directed) {
	             GraphConstants.setLineEnd(map, GraphConstants.ARROW_CLASSIC);
	             GraphConstants.setEndFill(map, true);
	           }
	           decodeEdge(edge_node, map);
	           attributes.put(edge, map);

	           // Add Edge to new Cells
	           newCells.add(edge);
	         }
	         else if (type.equals("view")) { // Graph view attributes
	           // Currently defined: defaultlayout
	           defaultLayout = ( (Element) node).getAttribute("defaultlayout");
	         }
	       }
	     }
	   }
	 }
	 // Insert the cells (View stores attributes)
	 model.insert(newCells.toArray(), attributes, cs, null, null);
	 
	}

	/**
	* Returns an attributeMap for the specified position and color.
	*/
	protected static Map createDefaultAttributes(Map map) {
	 // Set a Black Line Border (the Border-Attribute must be Null!)
	 GraphConstants.setBorderColor(map, Color.black);
	 // Return the Map
	 return map;
	}

//	 Fetch Cell Label from Node
	protected static String getLabel(Node node) {
	 String lab = null;
	 NodeList children = node.getChildNodes();
	 for (int j = 0; j < children.getLength(); j++) {
	   Node attr = children.item(j);
	   if (attr.getNodeName().equals("attr")
	       && attr.getAttributes().getNamedItem("name").getNodeValue().equals(
	       "Label")) {
	     NodeList values = attr.getChildNodes();
	     for (int k = 0; k < values.getLength(); k++) {
	       if (values.item(k).getNodeName().equals("string")) {
	         Node labelNode = values.item(k).getFirstChild();
	         if (labelNode != null) {
	           lab = labelNode.getNodeValue();
	         }
	       }
	     }
	   }
	 }
	 return (lab != null) ? lab : new String("");
	}
}