workflow_jgraphgxlcodec.java

用java实现的工作流

    }
    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("");
  }

}