Пример #1
0
  public DefaultMutableTreeNode findNode(DefaultMutableTreeNode parent, String match) {
    if (parent == null) return null;
    // Commented by Balan on 15/03/03
    // String treename =  (String)parent.getUserObject ();
    // Comment Ends

    // Added by Balan  on 15/03/03
    String treename = "" + ((Hashtable) parent.getUserObject()).get("TREE-NAME");
    // Add Ends

    if (treename != null) {
      if (treename.equals(match)) return parent;
    }

    if (frame.model.isLeaf(parent)) return null;

    Enumeration en = parent.children();
    if ((en == null) || (!en.hasMoreElements())) return null;
    for (; en.hasMoreElements(); ) {

      DefaultMutableTreeNode child = (DefaultMutableTreeNode) en.nextElement();
      DefaultMutableTreeNode returnNode = findNode(child, match);
      if (returnNode != null) return returnNode;
    }
    return null;
  }
Пример #2
0
 public Vector getAssociatedLevelLists() {
   Vector levelLists = new Vector();
   Vector endPts = CollectionHelper.makeVector("Keyword");
   Hashtable keywordParents =
       oncotcap.Oncotcap.getDataSource()
           .getParentTree(
               "Keyword", endPts, CollectionHelper.makeVector(this), TreeDisplayModePanel.ROOT);
   // Take each of the parents and get the associated level lists
   if (keywordParents.size() <= 0) return levelLists;
   Hashtable levelListsHashtable =
       oncotcap.Oncotcap.getDataSource()
           .getInstanceTree(
               "EnumLevelList",
               new Vector(),
               makeLevelListFilter(keywordParents),
               TreeDisplayModePanel.ROOT);
   for (Enumeration e = keywordParents.keys(); e.hasMoreElements(); ) {
     System.out.println("Keyword.getAssociatedLevelLists: " + e.nextElement());
   }
   // Collect all the level lists from the hashtable
   Vector selectedItems = CollectionHelper.makeVector(keyword);
   for (Enumeration e = levelListsHashtable.keys(); e.hasMoreElements(); ) {
     Object obj = e.nextElement();
     if (obj instanceof EnumLevelList) {
       levelLists.addElement(obj);
     }
   }
   return levelLists;
 }
Пример #3
0
 /** Draws the edge structure of the tree */
 public void drawEdges(Graphics2D gg) {
   gg.setPaint(Color.black);
   Enumeration nodeList = argument.getBreadthFirstTraversal().elements();
   // For each vertex...
   while (nodeList.hasMoreElements()) {
     // Get its edge list...
     TreeVertex vertex = (TreeVertex) nodeList.nextElement();
     Enumeration edges = vertex.getEdgeList().elements();
     // For each edge in the list...
     while (edges.hasMoreElements()) {
       TreeEdge edge = (TreeEdge) edges.nextElement();
       // If we have several vertices on layer 0, only draw
       // edges for layers below that
       if (!(argument.isMultiRoots() && vertex.getLayer() == 0)) {
         // If the edge has been selected with the mouse,
         // use a thick line
         if (edge.isSelected()) {
           gg.setStroke(selectStroke);
         }
         gg.draw(edge.getShape(this));
         // If we used a thick line, reset the stroke to normal
         // line for next edge.
         if (edge.isSelected()) {
           gg.setStroke(solidStroke);
         }
         TreeVertex edgeSource = edge.getDestVertex();
       }
     }
   }
 }
Пример #4
0
  /**
   * Update the layouts tree.
   *
   * @param current The name of the current layout or <CODE>null</CODE> if none.
   */
  public void updateLayouts(Path current) throws PipelineException {
    DefaultMutableTreeNode root = null;
    {
      root = new DefaultMutableTreeNode(new TreeData(), true);

      {
        Path path = new Path(PackageInfo.getSettingsPath(), "layouts");
        rebuildTreeModel(path, new Path("/"), root);
      }

      DefaultTreeModel model = (DefaultTreeModel) pTree.getModel();
      model.setRoot(root);

      {
        Enumeration e = root.depthFirstEnumeration();
        if (e != null) {
          while (e.hasMoreElements()) {
            DefaultMutableTreeNode tnode = (DefaultMutableTreeNode) e.nextElement();
            pTree.expandPath(new TreePath(tnode.getPath()));
          }
        }
      }
    }

    pTree.clearSelection();
    if (current != null) {
      TreePath tpath = null;
      DefaultMutableTreeNode tnode = root;
      for (String comp : current.getComponents()) {
        DefaultMutableTreeNode next = null;
        Enumeration e = tnode.children();
        if (e != null) {
          while (e.hasMoreElements()) {
            DefaultMutableTreeNode child = (DefaultMutableTreeNode) e.nextElement();
            TreeData data = (TreeData) child.getUserObject();
            if (data.toString().equals(comp)) {
              tpath = new TreePath(child.getPath());
              next = child;
              break;
            }
          }
        }

        if (next == null) break;

        tnode = next;
      }

      if (tpath != null) {
        pTree.setSelectionPath(tpath);
        pTree.makeVisible(tpath);
      }
    }
  }
  protected void restoreTree() {
    Pair<ElementNode, List<ElementNode>> selection = storeSelection();

    DefaultMutableTreeNode root = getRootNode();
    if (!myShowClasses || myContainerNodes.isEmpty()) {
      List<ParentNode> otherObjects = new ArrayList<ParentNode>();
      Enumeration<ParentNode> children = getRootNodeChildren();
      ParentNode newRoot =
          new ParentNode(
              null, new MemberChooserObjectBase(getAllContainersNodeName()), new Ref<Integer>(0));
      while (children.hasMoreElements()) {
        final ParentNode nextElement = children.nextElement();
        if (nextElement instanceof ContainerNode) {
          final ContainerNode containerNode = (ContainerNode) nextElement;
          Enumeration<MemberNode> memberNodes = containerNode.children();
          List<MemberNode> memberNodesList = new ArrayList<MemberNode>();
          while (memberNodes.hasMoreElements()) {
            memberNodesList.add(memberNodes.nextElement());
          }
          for (MemberNode memberNode : memberNodesList) {
            newRoot.add(memberNode);
          }
        } else {
          otherObjects.add(nextElement);
        }
      }
      replaceChildren(root, otherObjects);
      sortNode(newRoot, myComparator);
      if (newRoot.children().hasMoreElements()) root.add(newRoot);
    } else {
      Enumeration<ParentNode> children = getRootNodeChildren();
      while (children.hasMoreElements()) {
        ParentNode allClassesNode = children.nextElement();
        Enumeration<MemberNode> memberNodes = allClassesNode.children();
        ArrayList<MemberNode> arrayList = new ArrayList<MemberNode>();
        while (memberNodes.hasMoreElements()) {
          arrayList.add(memberNodes.nextElement());
        }
        Collections.sort(arrayList, myComparator);
        for (MemberNode memberNode : arrayList) {
          myNodeToParentMap.get(memberNode).add(memberNode);
        }
      }
      replaceChildren(root, myContainerNodes);
    }
    myTreeModel.nodeStructureChanged(root);

    defaultExpandTree();

    restoreSelection(selection);
  }
Пример #6
0
  private void jButtonRequireSelectedStreamActionPerformed(
      java.awt.event.ActionEvent
          evt) { // GEN-FIRST:event_jButtonRequireSelectedStreamActionPerformed
    try {
      int index = jComboBoxRemoteServices.getSelectedIndex();
      if (index != -1) {

        final ServiceResponse service = availableServices.elementAt(index);

        final String stream = jComboBoxFileList.getSelectedItem().toString();
        System.out.println(
            "StreamClientJFrame.jButtonRequireSelectedFileActionPerformed stream " + stream);

        JRadioButton jrbStreamProtocol = null;
        for (Enumeration<?> e = buttonGroupStreamProtocol.getElements(); e.hasMoreElements(); ) {
          JRadioButton b = (JRadioButton) e.nextElement();
          if (b.getModel() == buttonGroupStreamProtocol.getSelection()) {
            jrbStreamProtocol = b;
          }
        }
        final String streamProtocol = jrbStreamProtocol.getText();

        JRadioButton jrbRampProtocol = null;
        for (Enumeration<?> e = buttonGroupRampProtocol.getElements(); e.hasMoreElements(); ) {
          JRadioButton b = (JRadioButton) e.nextElement();
          if (b.getModel() == buttonGroupRampProtocol.getSelection()) {
            jrbRampProtocol = b;
          }
        }
        final String rampProtocol = jrbRampProtocol.getText();

        // sc.getStream(service, stream, streamProtocol, rampProtocol);
        Thread t =
            new Thread(
                new Runnable() {
                  @Override
                  public void run() {
                    try {
                      sc.getStream(service, stream, streamProtocol, rampProtocol);
                    } catch (Exception ex) {
                      ex.printStackTrace();
                    }
                  }
                });
        t.start();
      }
    } catch (Exception e) {
      e.printStackTrace();
    }
  } // GEN-LAST:event_jButtonRequireSelectedStreamActionPerformed
    private void restorePath(ArrayList<Object> newPath, int idx) {
      if (idx >= myPath.length) return;
      InspectionTreeNode oldNode = (InspectionTreeNode) myPath[idx];

      InspectionTreeNode newRoot = (InspectionTreeNode) newPath.get(idx - 1);

      InspectionResultsViewComparator comparator = InspectionResultsViewComparator.getInstance();
      Enumeration children = newRoot.children();
      while (children.hasMoreElements()) {
        InspectionTreeNode child = (InspectionTreeNode) children.nextElement();
        if (comparator.compare(child, oldNode) == 0) {
          newPath.add(child);
          restorePath(newPath, idx + 1);
          return;
        }
      }

      // Exactly same element not found. Trying to select somewhat near.
      int count = newRoot.getChildCount();
      if (count > 0) {
        if (myIndicies[idx] < count) {
          newPath.add(newRoot.getChildAt(myIndicies[idx]));
        } else {
          newPath.add(newRoot.getChildAt(count - 1));
        }
      }
    }
Пример #8
0
  // ------------------------------------------------------------------------
  // SCREEN PAINTER
  // Put some function here to paint whatever you want over the screen before and after
  // all edges and nodes have been painted.
  public void PaintScreenBefore(Graphics g) {

    Dimension d = MainClass.mainFrame.GetGraphDisplayPanel().getSize();
    NodeInfo nodeInfo;
    int x = 0;
    int y = 0;
    int step = 10;

    for (; x < d.width; x += step) {
      for (y = 0; y < d.height; y += step) {
        double val = 0;
        double sum = 0;
        double total = 0;
        double min = 10000000;
        for (Enumeration nodes = proprietaryNodeInfo.elements(); nodes.hasMoreElements(); ) {
          nodeInfo = (NodeInfo) nodes.nextElement();
          double dist = distance(x, y, nodeInfo.centerX, nodeInfo.centerY);
          if (nodeInfo.value != -1 && nodeInfo.nodeNumber.intValue() != 1) { // 121
            if (dist < min) min = dist;
            val += ((double) nodeInfo.value) / dist / dist;
            sum += (1 / dist / dist);
          }
        }
        int reading = (int) (val / sum);
        reading = reading >> 2;
        if (reading > 255) reading = 255;
        g.setColor(new Color(reading, reading, reading));
        g.fillRect(x, y, step, step);
      }
    }
  }
 private void checkNodeValidity(@NotNull DefaultMutableTreeNode node) {
   Enumeration enumeration = node.children();
   while (enumeration.hasMoreElements()) {
     checkNodeValidity((DefaultMutableTreeNode) enumeration.nextElement());
   }
   if (node instanceof Node && node != getModelRoot()) ((Node) node).update(this);
 }
Пример #10
0
 /** Description of the Method */
 public void removeAllElements() {
   for (Enumeration<BPM_Element> e = listModel.elements(); e.hasMoreElements(); ) {
     BPM_Element elm = e.nextElement();
     elm.stopMonitor();
   }
   listModel.removeAllElements();
 }
Пример #11
0
  void drawboard(Graphics g) {
    g.setColor(Color.black);
    g.fillRect(0, 0, getWidth(), getHeight());

    sqw = getWidth() / xdim;
    sqh = getHeight() / ydim;

    // draw background panels
    if (def != null) {
      for (int y = 0; y < ydim; y++) {
        for (int x = 0; x < xdim; x++) def.drawObject(g, x, y, sqw, sqh, this);
      }
    }

    if (USEVEC) {
      // draw each element in the vector
      for (Enumeration e = boardVec.elements(); e.hasMoreElements(); ) {
        boardContainer c = (boardContainer) e.nextElement();
        c.o.drawObject(g, c.d.width, c.d.height, sqw, sqh, this);
      }
    } else {
      // draw from grid
      for (int y = 0; y < ydim; y++) {
        for (int x = 0; x < xdim; x++)
          if (board[x][y] != null) board[x][y].drawObject(g, x, y, sqw, sqh, this);
      }
    }
  }
Пример #12
0
  protected final void loadChildren(DynamicNode node) throws DbException {
    if (node.hasLoaded() || node.isLeaf()) return;
    node.setHasLoaded();
    Object userObject = node.getUserObject();
    if (userObject == ROOT) return;
    SrVector children = new SrVector(10);
    boolean isSorted = true;
    DbObject dbParent = null;
    if (userObject == DB_RAM) {
      Db[] dbs = Db.getDbs();
      for (int i = 0; i < dbs.length; i++) {
        if (dbs[i] instanceof DbRAM) insertProjects(children, dbs[i]);
      }
    } else if (userObject instanceof Db) {
      insertProjects(children, (Db) userObject);
    } else {
      dbParent = (DbObject) userObject;
      dbParent.getDb().beginTrans(Db.READ_TRANS);
      insertComponents(children, dbParent);
      isSorted = childrenAreSorted(dbParent);
      dbParent.getDb().commitTrans();
    }

    if (isSorted) {
      children.sort(getComparator(dbParent));
    }

    ArrayList groupNodeList = new ArrayList();
    DynamicNode groupNode = null;
    Enumeration enumeration = children.elements();
    while (enumeration.hasMoreElements()) {
      DynamicNode childNode = (DynamicNode) enumeration.nextElement();
      GroupParams group = childNode.getGroupParams();
      if (group.name == null) {
        node.add(childNode);
      } else {
        if (groupNode == null) {
          groupNode = createGroupNode(group);
          node.add(groupNode);
          groupNodeList.add(groupNode);
        } else if (!groupNode.toString().equals(group.name)) {
          boolean groupFound = false;
          for (int i = 0; i < groupNodeList.size(); i++) {
            groupNode = (DynamicNode) groupNodeList.get(i);
            if (groupNode.toString().equals(group.name)) {
              groupFound = true;
              break;
            }
          }
          if (!groupFound) {
            groupNode = createGroupNode(group);
            node.add(groupNode);
            groupNodeList.add(groupNode);
          }
        }
        groupNode.add(childNode);
      }
    }
    groupNodeList.clear();
  }
  public HierarchyBrowserBaseEx(@NotNull Project project, @NotNull PsiElement element) {
    super(project);

    setHierarchyBase(element);

    myCardLayout = new CardLayout();
    myTreePanel = new JPanel(myCardLayout);

    createTrees(myType2TreeMap);

    final HierarchyBrowserManager.State state =
        HierarchyBrowserManager.getInstance(project).getState();
    for (String type : myType2TreeMap.keySet()) {
      myType2ScopeMap.put(type, state.SCOPE != null ? state.SCOPE : SCOPE_ALL);
    }

    final Enumeration<String> keys = myType2TreeMap.keys();
    while (keys.hasMoreElements()) {
      final String key = keys.nextElement();
      final JTree tree = myType2TreeMap.get(key);
      myOccurrenceNavigators.put(
          key,
          new OccurenceNavigatorSupport(tree) {
            @Override
            @Nullable
            protected Navigatable createDescriptorForNode(DefaultMutableTreeNode node) {
              final HierarchyNodeDescriptor descriptor = getDescriptor(node);
              if (descriptor == null) return null;
              PsiElement psiElement = getOpenFileElementFromDescriptor(descriptor);
              if (psiElement == null || !psiElement.isValid()) return null;
              final VirtualFile virtualFile = psiElement.getContainingFile().getVirtualFile();
              if (virtualFile == null) return null;
              return new OpenFileDescriptor(
                  psiElement.getProject(), virtualFile, psiElement.getTextOffset());
            }

            @Override
            public String getNextOccurenceActionName() {
              return getNextOccurenceActionNameImpl();
            }

            @Override
            public String getPreviousOccurenceActionName() {
              return getPrevOccurenceActionNameImpl();
            }
          });
      myTreePanel.add(ScrollPaneFactory.createScrollPane(tree), key);
    }

    final JPanel legendPanel = createLegendPanel();
    final JPanel contentPanel;
    if (legendPanel != null) {
      contentPanel = new JPanel(new BorderLayout());
      contentPanel.add(myTreePanel, BorderLayout.CENTER);
      contentPanel.add(legendPanel, BorderLayout.SOUTH);
    } else {
      contentPanel = myTreePanel;
    }
    buildUi(createToolbar(getActionPlace(), HELP_ID).getComponent(), contentPanel);
  }
Пример #14
0
 /**
  * notify listeners of a popup selection
  *
  * @param popStr popup selection string
  */
 void popNotify(String popStr) {
   Enumeration en = popListeners.elements();
   for (; en.hasMoreElements(); ) {
     PopListener listener = (PopListener) en.nextElement();
     listener.popHappened(popStr);
   }
 } // popNotify()
 private void traverseToLeaves(
     final PackageDependenciesNode treeNode,
     final StringBuffer denyRules,
     final StringBuffer allowRules) {
   final Enumeration enumeration = treeNode.breadthFirstEnumeration();
   while (enumeration.hasMoreElements()) {
     PsiElement childPsiElement =
         ((PackageDependenciesNode) enumeration.nextElement()).getPsiElement();
     if (myIllegalDependencies.containsKey(childPsiElement)) {
       final Map<DependencyRule, Set<PsiFile>> illegalDeps =
           myIllegalDependencies.get(childPsiElement);
       for (final DependencyRule rule : illegalDeps.keySet()) {
         if (rule.isDenyRule()) {
           if (denyRules.indexOf(rule.getDisplayText()) == -1) {
             denyRules.append(rule.getDisplayText());
             denyRules.append("\n");
           }
         } else {
           if (allowRules.indexOf(rule.getDisplayText()) == -1) {
             allowRules.append(rule.getDisplayText());
             allowRules.append("\n");
           }
         }
       }
     }
   }
 }
Пример #16
0
 private static void expand(JTree tree, TreePath path, int levels) {
   if (levels == 0) return;
   tree.expandPath(path);
   TreeNode node = (TreeNode) path.getLastPathComponent();
   Enumeration children = node.children();
   while (children.hasMoreElements()) {
     expand(tree, path.pathByAddingChild(children.nextElement()), levels - 1);
   }
 }
Пример #17
0
 // {{{ traverseNodes() method
 public static boolean traverseNodes(
     DefaultMutableTreeNode node, HyperSearchTreeNodeCallback callbackInterface) {
   if (!callbackInterface.processNode(node)) return false;
   for (Enumeration e = node.children(); e.hasMoreElements(); ) {
     DefaultMutableTreeNode childNode = (DefaultMutableTreeNode) e.nextElement();
     if (!traverseNodes(childNode, callbackInterface)) return false;
   }
   return true;
 } // }}}
Пример #18
0
 @Override
 public void actionPerformed(ActionEvent evt) {
   TreePath path = resultTree.getSelectionPath();
   DefaultMutableTreeNode operNode = (DefaultMutableTreeNode) path.getLastPathComponent();
   for (Enumeration e = operNode.children(); e.hasMoreElements(); ) {
     DefaultMutableTreeNode node = (DefaultMutableTreeNode) e.nextElement();
     resultTree.collapsePath(new TreePath(node.getPath()));
   }
   resultTree.scrollPathToVisible(new TreePath(operNode.getPath()));
 }
 /*
  * Applet is no longer displayed
  */
 public void stop() {
   // Tell all pages to stop talking to the server
   Enumeration e = pages.elements();
   while (e.hasMoreElements()) {
     SOAPMonitorPage pg = (SOAPMonitorPage) e.nextElement();
     if (pg != null) {
       pg.stop();
     }
   }
 }
Пример #20
0
 private int getChildIndex(InspectionTreeNode node, InspectionTreeNode child) {
   int idx = 0;
   Enumeration children = node.children();
   while (children.hasMoreElements()) {
     InspectionTreeNode ch = (InspectionTreeNode) children.nextElement();
     if (ch == child) break;
     idx++;
   }
   return idx;
 }
 private void step() {
   myNext = null;
   while (myEnum.hasMoreElements()) {
     final Object o = myEnum.nextElement();
     if (o instanceof FileTreeNode) {
       myNext = ((FileTreeNode) o).getFilePointer();
       break;
     }
   }
 }
 /**
  * Writes all of the edge comments to the writer to create the comment file and whether a datamap
  * entry is generated or not. Each line represents an entry of the datamap. Each line contains a 1
  * or a 0 that signifies if generates or not and is followed by a comment if there is one.
  */
 public void writeComments(Writer commentWriter) throws IOException {
   // Write out all the edge comments
   Enumeration e = rep.edges();
   while (e.hasMoreElements()) {
     NamedEdge edge = (NamedEdge) e.nextElement();
     if (edge.isGenerated()) {
       commentWriter.write("1 " + edge.getComment() + '\n');
     } else commentWriter.write("0 " + edge.getComment() + '\n');
   }
 }
Пример #23
0
 protected final void updateInsertIndexInChildrenOfNode(DynamicNode parentNode)
     throws DbException {
   Enumeration childrenEnum = parentNode.children();
   while (childrenEnum.hasMoreElements()) {
     DynamicNode node = (DynamicNode) childrenEnum.nextElement();
     DbObject dbo = (DbObject) node.getRealObject();
     DbObject dbParent = dbo.getComposite();
     node.insertIndex = getSequence(dbParent, dbo);
   }
 }
  private static void sortNode(ParentNode node, final Comparator<ElementNode> sortComparator) {
    ArrayList<MemberNode> arrayList = new ArrayList<MemberNode>();
    Enumeration<MemberNode> children = node.children();
    while (children.hasMoreElements()) {
      arrayList.add(children.nextElement());
    }

    Collections.sort(arrayList, sortComparator);

    replaceChildren(node, arrayList);
  }
  /**
   * Writes out information for the datamap file (.dm file) .dm datamap file is in the format of:
   * number of vertices <br>
   * write out all vertices: &nbsp;&nbsp; |vertex type| &nbsp;&nbsp; |vertex id int| &nbsp;&nbsp;
   * |number of enumerations| &nbsp;&nbsp; |enumeration strings .....| <br>
   * number of edges <br>
   * write out all edges: &nbsp;&nbsp; | left vertex | &nbsp;&nbsp; |name of edge| &nbsp;&nbsp;
   * |right vertex|
   *
   * @param graphWriter the file to be written too - .dm file
   */
  public void write(Writer graphWriter) throws IOException {
    // Write out the number of Vertices
    graphWriter.write("" + rep.numberOfVertices() + '\n');

    // Write out all the vertices
    Enumeration v = rep.vertices();
    while (v.hasMoreElements()) {
      SoarVertex vertex = (SoarVertex) v.nextElement();
      if (vertex != null) vertex.write(graphWriter);
    }

    // Write out the number of edges
    graphWriter.write("" + rep.numberOfEdges() + '\n');
    // Write out all the edges
    Enumeration e = rep.edges();
    while (e.hasMoreElements()) {
      NamedEdge edge = (NamedEdge) e.nextElement();
      edge.write(graphWriter);
    }
  }
  private Set<Object> addPaths(Enumeration elements) {
    ArrayList<Object> elementArray = new ArrayList<Object>();
    if (elements != null) {
      while (elements.hasMoreElements()) {
        Object each = elements.nextElement();
        elementArray.add(each);
      }
    }

    return addPaths(elementArray);
  }
Пример #27
0
 // Get what the user selects as the answer
 public String getSelection() {
   String selectedChoice = null;
   Enumeration<AbstractButton> buttons = bg.getElements();
   while (buttons.hasMoreElements()) {
     JRadioButton temp = (JRadioButton) buttons.nextElement();
     if (temp.isSelected()) {
       selectedChoice = temp.getText();
     }
   }
   return (selectedChoice);
 }
 @Override
 public JComponent getPreferredFocusedComponent() {
   final Enumeration<AbstractButton> enumeration = myGroup.getElements();
   while (enumeration.hasMoreElements()) {
     final AbstractButton button = enumeration.nextElement();
     if (button.isSelected()) {
       return button;
     }
   }
   return myPanel;
 }
Пример #29
0
 /**
  * Returns the bPM attribute of the BPMsTable object
  *
  * @param name The Parameter
  * @return The bPM value
  */
 public BPM_Element getBPM(String name) {
   BPM_Element bpmElm = null;
   Enumeration<BPM_Element> bpm_enum = listModel.elements();
   while (bpm_enum.hasMoreElements()) {
     BPM_Element bpmElm1 = bpm_enum.nextElement();
     if (bpmElm1.getName().equals(name)) {
       bpmElm = bpmElm1;
     }
   }
   return bpmElm;
 }
Пример #30
0
 public void save(PrintStream stream) {
   saved = true;
   stream.println("<?xml version=\"1.0\"?>");
   stream.println("<scale>");
   stream.println("  <name>" + nameTF.getText() + "</name>");
   for (Enumeration en = sp.notes.elements(); en.hasMoreElements(); ) {
     ScalePanel.Notik cur = (ScalePanel.Notik) en.nextElement();
     stream.println("  <note>" + cur.n + "</note>");
   }
   stream.println("</scale>");
 }