private static DefaultMutableTreeNode findMatchedChild( DefaultMutableTreeNode parent, PathElement pathElement) { for (int j = 0; j < parent.getChildCount(); j++) { final TreeNode child = parent.getChildAt(j); if (!(child instanceof DefaultMutableTreeNode)) continue; final DefaultMutableTreeNode childNode = (DefaultMutableTreeNode) child; final Object userObject = childNode.getUserObject(); if (pathElement.matchedWithByObject(userObject)) return childNode; } for (int j = 0; j < parent.getChildCount(); j++) { final TreeNode child = parent.getChildAt(j); if (!(child instanceof DefaultMutableTreeNode)) continue; final DefaultMutableTreeNode childNode = (DefaultMutableTreeNode) child; final Object userObject = childNode.getUserObject(); if (!(userObject instanceof NodeDescriptor)) continue; final NodeDescriptor nodeDescriptor = (NodeDescriptor) userObject; if (pathElement.matchedWith(nodeDescriptor)) return childNode; } if (parent.getChildCount() > 0) { int index = pathElement.myItemIndex; if (index >= parent.getChildCount()) { index = parent.getChildCount() - 1; } final TreeNode child = parent.getChildAt(index); if (child instanceof DefaultMutableTreeNode) { return (DefaultMutableTreeNode) child; } } return null; }
// =============================================================== // =============================================================== void putPoolThreadInfo() { // ToDo // Get configuration from tree int nbThreads = root.getChildCount(); ArrayList<String> lines = new ArrayList<String>(); for (int i = 0; i < root.getChildCount(); i++) { DefaultMutableTreeNode threadNode = (DefaultMutableTreeNode) root.getChildAt(i); int deviceNumber = threadNode.getChildCount(); if (deviceNumber > 0) { String s = ""; for (int j = 0; j < deviceNumber; j++) { s += threadNode.getChildAt(j).toString(); if (j < deviceNumber - 1) s += ","; } lines.add(s); } } // Check for maximum length of lines lines = manageMaxLength(lines); // Convert tree to device(admin) property. String[] config = new String[lines.size()]; for (int i = 0; i < lines.size(); i++) config[i] = lines.get(i); // And send it to database. try { DbDatum[] argin = new DbDatum[2]; argin[0] = new DbDatum(propertyNames[NB_THREADS], nbThreads); argin[1] = new DbDatum(propertyNames[THREADS_CONFIG], config); server.put_property(argin); } catch (DevFailed e) { ErrorPane.showErrorMessage(parent, null, e); } }
/** * @param defaultTreeModel * @param root * @see BuildingTree */ public void toTree(final DefaultTreeModel defaultTreeModel, DefaultMutableTreeNode root) { ArrayList a = (ArrayList) DataToTest.getBuildingCollection(); DefaultMutableTreeNode bNode; DefaultMutableTreeNode fNode; DefaultMutableTreeNode rNode; for (Iterator i = a.iterator(); i.hasNext(); ) { Building building = (Building) i.next(); bNode = new DefaultMutableTreeNode(building); defaultTreeModel.insertNodeInto(bNode, root, root.getChildCount()); if (building.getFloor().length > 0) { for (int floorCount = 0; floorCount < building.getFloor().length; floorCount++) { Floor fl = (Floor) building.getFloor()[floorCount]; fNode = new DefaultMutableTreeNode(fl); defaultTreeModel.insertNodeInto(fNode, bNode, bNode.getChildCount()); if (fl.getRoom().length > 0) { for (int roomIterator = 0; roomIterator < fl.getRoom().length; roomIterator++) { Room r = (Room) fl.getRoom()[roomIterator]; rNode = new DefaultMutableTreeNode(r); defaultTreeModel.insertNodeInto(rNode, fNode, fNode.getChildCount()); } } } } } }
/** * Remove this node from the model. * * @param node * @param model */ private void removeFromModel(DefaultMutableTreeNode node, DefaultTreeModel model) { model.removeNodeFromParent(node); nodeTable.remove(node.getUserObject()); // remove the type branch if there are no more children switch (treeMode) { case TYPE: String typeString = ((GeoElement) node.getUserObject()).getObjectType(); DefaultMutableTreeNode parent = (DefaultMutableTreeNode) typeNodesMap.get(typeString); // this has been the last node if (parent.getChildCount() == 0) { typeNodesMap.remove(typeString); model.removeNodeFromParent(parent); } break; case LAYER: int layer = ((GeoElement) node.getUserObject()).getLayer(); parent = (DefaultMutableTreeNode) layerNodesMap.get(layer); // this has been the last node if (parent.getChildCount() == 0) { layerNodesMap.remove(layer); model.removeNodeFromParent(parent); } break; } }
/** * 参数条件树上增加节点 * * @param conditionNodeObj */ private TreeNode addParaTreNode(IStatisticCaliber aCal) { // 得到父节点 DefaultTreeModel treeModel = (DefaultTreeModel) treWhere.getModel(); DefaultMutableTreeNode root = (DefaultMutableTreeNode) treeModel.getRoot(); // 判断增加的父节点是否已存在,默认父节点不存在 boolean sFlag = false; IStatisticCaliber curCal = null; DefaultMutableTreeNode curNode = null; int iChildCount = root.getChildCount(); // 得到根节点下的子节点 for (int i = 0; i < iChildCount; i++) { curNode = (DefaultMutableTreeNode) root.getChildAt(i); curCal = ((Caliber) curNode.getUserObject()).getACal(); if (aCal.getSourceID().equals(curCal.getSourceID())) { sFlag = true; break; } } DefaultMutableTreeNode ANode = null; if (!sFlag) { // 父节点不存在 // 增加父节点 ICustomStatisticCaliber parCal = new MySummaryStatisticCaliberImpl(); parCal.setSourceID(aCal.getSourceID()); // 数据源名称 String sDataSourceName = dataSourceCbx.getRefModel().getNameByValue(aCal.getSourceID()); parCal.setValue(sDataSourceName); ANode = new DefaultMutableTreeNode(new Caliber(parCal)); treeModel.insertNodeInto(ANode, root, root.getChildCount()); curNode = (DefaultMutableTreeNode) root.getLastChild(); } ANode = new DefaultMutableTreeNode(new Caliber(aCal)); treeModel.insertNodeInto(ANode, curNode, curNode.getChildCount()); return ANode; }
public void reload() { removeNodes(); DefaultMutableTreeNode hostNode = new DefaultMutableTreeNode(Main.getLocalhost()); treeModel.insertNodeInto(hostNode, rootNode, rootNode.getChildCount()); for (Trigger trigger : Main.getTriggerManager().getTriggers()) { DefaultMutableTreeNode triggerNode = new DefaultMutableTreeNode(trigger); treeModel.insertNodeInto(triggerNode, hostNode, hostNode.getChildCount()); } expandAll(); }
/** * Obtain a default dir, if there is one, which would have been passed in via a -p argument. Try * to expand the dir in the file tree. */ public void expandDefaultDir() { // do an overall try catch. Don't want an exception here bringing down // the app. try { String defaultDir = FileUtilities.getDefaultDir(); if (defaultDir == null) { return; } File file = new File(defaultDir); if (!file.exists() || !file.isDirectory()) { return; } String path = file.getCanonicalPath(); // break the path into components String tokens[] = FileUtilities.tokenizePath(path); if (tokens == null) { return; } DefaultMutableTreeNode root = (DefaultMutableTreeNode) getModel().getRoot(); if ((root == null) || (root.getChildCount() < 1)) { return; } int tokenIndex = 0; while ((root != null) && (root.getChildCount() > 0) && (tokenIndex < tokens.length)) { String token = tokens[tokenIndex]; tokenIndex++; DefaultMutableTreeNode newRoot = getChild(root, token); if (newRoot != null) { TreeNode pathnodes[] = ((DefaultTreeModel) getModel()).getPathToRoot(newRoot); TreePath cpath = new TreePath(pathnodes); scrollPathToVisible(cpath); expandPath(cpath); newRoot = getChild(root, token); pathnodes = ((DefaultTreeModel) getModel()).getPathToRoot(newRoot); } root = newRoot; } } catch (Exception e) { e.printStackTrace(); } }
/** * A helper method to search for a class node. * * @param cls * @return */ private DefaultMutableTreeNode searchClassNode(SchemaClass cls) { SchemaClass displayedCls = getDisplayedPESubclass(cls); DefaultMutableTreeNode root = (DefaultMutableTreeNode) tree.getModel().getRoot(); if (root.getChildCount() == 0) { return null; } for (int i = 0; i < root.getChildCount(); i++) { DefaultMutableTreeNode child = (DefaultMutableTreeNode) root.getChildAt(i); if (child.getUserObject() == displayedCls) return child; } return null; }
private void removeModificationListenerRecursiv(DefaultMutableTreeNode node) { int childCount = 0; if (node instanceof UserNode) { ((UserNode) node).removeModificationListener(); if (((UserNode) node).isInitialized()) childCount = node.getChildCount(); } else childCount = node.getChildCount(); if (childCount > 0) { for (int i = 0; i < childCount; i++) { removeModificationListenerRecursiv((DefaultMutableTreeNode) node.getChildAt(i)); } } }
// =============================================================== // =============================================================== private DefaultMutableTreeNode getFutureSelectedNode(DefaultMutableTreeNode node) { // Get the future selectd node, after remove. DefaultMutableTreeNode parent_node = (DefaultMutableTreeNode) node.getParent(); DefaultMutableTreeNode ret_node = parent_node; for (int i = 0; i < parent_node.getChildCount(); i++) { DefaultMutableTreeNode child_node = (DefaultMutableTreeNode) parent_node.getChildAt(i); if (child_node == node) { if (i == parent_node.getChildCount() - 1) { if (i > 0) ret_node = (DefaultMutableTreeNode) parent_node.getChildAt(i - 1); } else ret_node = (DefaultMutableTreeNode) parent_node.getChildAt(i + 1); } } return ret_node; }
/** * Selecciona la unidad y la lista con sus hijos, para poder ser eliminados de la base de datos. * * @param raiz Nodo por el que se comienza a contar las unidades que se van a eliminar. * @return Lista con todas las unidades que se van a eliminar. */ private ArrayList<Unidad> seleccionarAEliminar(DefaultMutableTreeNode raiz) { ArrayList<Unidad> aEliminar = new ArrayList<Unidad>(); if (raiz.getChildCount() != 0) { for (int i = 0; i < raiz.getChildCount(); i++) { aEliminar.addAll(seleccionarAEliminar((DefaultMutableTreeNode) raiz.getChildAt(i))); } } aEliminar.add(((UnidadUserObject) raiz.getUserObject()).getUnidad()); return aEliminar; }
public synchronized void buildFilteredModel(String text) { filtered_root.removeAllChildren(); ArrayList<DefaultMutableTreeNode> rows = new ArrayList<>(); if (staff.getChildCount() > 0) { DefaultMutableTreeNode filtered = new DefaultMutableTreeNode("Staff"); filterNode(staff, text, filtered); if (filtered.getChildCount() > 0) { filtered_root.add(filtered); rows.add(filtered); } } if (admins.getChildCount() > 0) { DefaultMutableTreeNode filtered = new DefaultMutableTreeNode("Admins"); filterNode(admins, text, filtered); if (filtered.getChildCount() > 0) { filtered_root.add(filtered); rows.add(filtered); } } if (global_mods.getChildCount() > 0) { DefaultMutableTreeNode filtered = new DefaultMutableTreeNode("Global Moderators"); filterNode(global_mods, text, filtered); if (filtered.getChildCount() > 0) { filtered_root.add(filtered); rows.add(filtered); } } if (mods.getChildCount() > 0) { DefaultMutableTreeNode filtered = new DefaultMutableTreeNode("Moderators"); filterNode(mods, text, filtered); if (filtered.getChildCount() > 0) { filtered_root.add(filtered); rows.add(filtered); } } if (viewers.getChildCount() > 0) { DefaultMutableTreeNode filtered = new DefaultMutableTreeNode("Viewers"); filterNode(viewers, text, filtered); if (filtered.getChildCount() > 0) { filtered_root.add(filtered); rows.add(filtered); } } setViewerTreeModel(new DefaultTreeModel(filtered_root)); for (DefaultMutableTreeNode row : rows) { TreePath tp = new TreePath(row.getPath()); viewerTree.expandPath(tp); } }
private synchronized void updateRoot(Enumeration<TreePath> userPath) { DefaultMutableTreeNode root = default_root; root.removeAllChildren(); if (staff.getChildCount() > 0) root.add(staff); if (admins.getChildCount() > 0) root.add(admins); if (global_mods.getChildCount() > 0) root.add(global_mods); if (mods.getChildCount() > 0) root.add(mods); root.add(viewers); if (!isFiltering) defaultModel.reload(root); if (userPath != null) { while (userPath.hasMoreElements()) { viewerTree.expandPath(userPath.nextElement()); } } }
private void buildTreeFromString(DefaultTreeModel model, final String str) { // Fetch the root node DefaultMutableTreeNode root = (DefaultMutableTreeNode) model.getRoot(); // Split the string around the delimiter String[] strings = str.split("/"); // Create a node object to use for traversing down the tree as it // is being created DefaultMutableTreeNode node = root; // Iterate of the string array for (String s : strings) { // Look for the index of a node at the current level that // has a value equal to the current string int index = childIndex(node, s); // Index less than 0, this is a new node not currently present on // the tree if (index < 0) { // Add the new node DefaultMutableTreeNode newChild = new DefaultMutableTreeNode(s); node.insert(newChild, node.getChildCount()); node = newChild; } // Else, existing node, skip to the next string else { node = (DefaultMutableTreeNode) node.getChildAt(index); } } }
private static boolean isMoveSupported(JTree tree, int dir) { final TreePath[] selectionPaths = tree.getSelectionPaths(); if (selectionPaths != null) { DefaultMutableTreeNode parent = null; for (TreePath treePath : selectionPaths) if (treePath.getLastPathComponent() != null) { final DefaultMutableTreeNode node = (DefaultMutableTreeNode) treePath.getLastPathComponent(); if (parent == null) { parent = (DefaultMutableTreeNode) node.getParent(); } if (parent != node.getParent()) { return false; } if (dir > 0) { if (parent.getIndex(node) == parent.getChildCount() - 1) { return false; } } else { if (parent.getIndex(node) == 0) { return false; } } } return true; } return false; }
public void updateClientState(Node nodeUpdate) { for (int i = 0; i < rootNode.getChildCount(); i++) { TreeNode treeNode = rootNode.getChildAt(i); // System.out.println(treeNode.toString()); if (treeNode.toString().equals(nodeUpdate.getName())) { DefaultMutableTreeNode node = (DefaultMutableTreeNode) treeNode; if (nodeUpdate.isOnline() && nodeUpdate.isValid()) { // 删除”状态:在线,可信“ 那一行 node.remove(2); node.add(new DefaultMutableTreeNode("状态:在线,可信")); Log.i(this.getClass().getName(), nodeUpdate.getName() + " 已登录,状态可信."); } else if (nodeUpdate.isOnline() && !nodeUpdate.isValid()) { node.remove(2); node.add(new DefaultMutableTreeNode("状态:在线,不可信")); Log.v( this.getClass().getName(), nodeUpdate.getName() + "状态不可信,IP地址为:" + nodeUpdate.getIP()); } else { node.remove(2); node.add(new DefaultMutableTreeNode("状态:离线")); Log.i( this.getClass().getName(), nodeUpdate.getName() + "不在线,IP地址为:" + nodeUpdate.getIP()); } this.jTree.updateUI(); return; } } }
private ArrayList<TreeNode> childrenToArray(DefaultMutableTreeNode node) { ArrayList<TreeNode> arrayList = new ArrayList<TreeNode>(); for (int i = 0; i < node.getChildCount(); i++) { arrayList.add(node.getChildAt(i)); } return arrayList; }
private void collapseTargets() { DefaultMutableTreeNode root = (DefaultMutableTreeNode) myTreeModel.getRoot(); for (int i = 0; i < root.getChildCount(); i++) { DefaultMutableTreeNode node = (DefaultMutableTreeNode) root.getChildAt(i); myTree.collapsePath(new TreePath(node.getPath())); } }
public void removeMarker(LogMarker marker) { DefaultMutableTreeNode node; for (int i = 0; i < markersNode.getChildCount(); i++) { node = (DefaultMutableTreeNode) markersNode.getChildAt(i); if (node.getUserObject() == marker) { markersNode.remove(node); } } if (markersNode.getChildCount() == 0) { root.remove(markersNode); markersNode = null; } treeModel.nodeStructureChanged(root); expandAllTree(); }
/** * Draw all primitives in this layer but do not draw modified ones (they are drawn by the edit * layer). Draw nodes last to overlap the ways they belong to. */ @SuppressWarnings("unchecked") @Override public void paint(final Graphics2D g, final MapView mv, Bounds bounds) { updateCount = Main.map.validatorDialog.tree.getUpdateCount(); DefaultMutableTreeNode root = Main.map.validatorDialog.tree.getRoot(); if (root == null || root.getChildCount() == 0) return; PaintVisitor paintVisitor = new PaintVisitor(g, mv); DefaultMutableTreeNode severity = (DefaultMutableTreeNode) root.getLastChild(); while (severity != null) { Enumeration<DefaultMutableTreeNode> errorMessages = severity.breadthFirstEnumeration(); while (errorMessages.hasMoreElements()) { Object tn = errorMessages.nextElement().getUserObject(); if (tn instanceof TestError) { paintVisitor.visit(((TestError) tn)); } } // Severities in inverse order severity = severity.getPreviousSibling(); } paintVisitor.clearPaintedObjects(); }
private void jTree1MouseClicked1( java.awt.event.MouseEvent evt) { // GEN-FIRST:event_jTree1MouseClicked1 if (evt.getClickCount() == 2 && evt.getButton() == evt.BUTTON1) { DefaultMutableTreeNode tn = (DefaultMutableTreeNode) jTree1.getSelectionPath().getLastPathComponent(); if (tn.getChildCount() > 0) return; /*if (!jTree1.isCollapsed( jTree1.getSelectionPath() )) { jTree1.collapsePath( jTree1.getSelectionPath() ); return; } * */ if (tn.getUserObject() instanceof TreeJRField) { TreeJRField jrf = (TreeJRField) tn.getUserObject(); if (!jrf.getObj().isPrimitive() && !jrf.getObj().getName().startsWith("java.lang.")) { exploreBean( tn, jrf.getObj().getName(), isPathOnDescription() ? Misc.nvl(jrf.getField().getDescription(), "") : Misc.nvl(jrf.getField().getName(), "")); } } } } // GEN-LAST:event_jTree1MouseClicked1
// =============================================================== // =============================================================== DefaultMutableTreeNode addThreadNode() { PollThread new_thread = new PollThread(getNextThreadNum()); DefaultMutableTreeNode node = new DefaultMutableTreeNode(new_thread); treeModel.insertNodeInto(node, root, root.getChildCount()); return node; }
private ArrayList<?> updateSelectedGeos(TreePath[] selPath) { selectionList.clear(); if (selPath != null) { // add all selected paths for (int i = 0; i < selPath.length; i++) { DefaultMutableTreeNode node = (DefaultMutableTreeNode) selPath[i].getLastPathComponent(); if (node == node.getRoot()) { // root: add all objects selectionList.clear(); selectionList.addAll(app.getKernel().getConstruction().getGeoSetLabelOrder()); i = selPath.length; } else if (node.getParent() == node.getRoot()) { // type node: select all children for (int k = 0; k < node.getChildCount(); k++) { DefaultMutableTreeNode child = (DefaultMutableTreeNode) node.getChildAt(k); selectionList.add(child.getUserObject()); } } else { // GeoElement selectionList.add(node.getUserObject()); } } } return selectionList; }
void onOK() { TreePath path = m_tree.getSelectionPath(); if (path == null) { JOptionPane.showMessageDialog(this, "Departement not yet been selected"); return; } DefaultMutableTreeNode node = (DefaultMutableTreeNode) path.getLastPathComponent(); if (!m_isroot) { if (node.getChildCount() > 0) return; if (node.getUserObject() instanceof Organization) { m_org = (Organization) node.getUserObject(); m_iResponse = JOptionPane.OK_OPTION; dispose(); } } else { if (node.getUserObject() instanceof Organization) { m_org = (Organization) node.getUserObject(); m_iResponse = JOptionPane.OK_OPTION; dispose(); } else { m_org = new Organization("", "", "Department"); m_iResponse = JOptionPane.OK_OPTION; dispose(); } } }
public void setWsdlModel(WSDLModel wsdlModel) { if (this.wsdlModel == wsdlModel) { return; } this.wsdlModel = wsdlModel; DefaultMutableTreeNode root = new DefaultMutableTreeNode(); for (Port port : Util.getSortedPorts(wsdlModel)) { Binding binding = port.getBinding().get(); List<BindingOperation> bindingOps = Util.getSortedBindingOperations(binding); if (bindingOps != null && bindingOps.size() > 0) { DefaultMutableTreeNode portNode = new DefaultMutableTreeNode(port); root.add(portNode); for (BindingOperation bindingOp : bindingOps) { DefaultMutableTreeNode bindingOpNode = new DefaultMutableTreeNode(bindingOp); portNode.add(bindingOpNode); bindingOpNode.setAllowsChildren(false); } } } DefaultTreeModel dtm = new DefaultTreeModel(root); mTree.setModel(dtm); int cnt = root.getChildCount(); for (int i = 0; i < cnt; i++) { mTree.expandPath(new TreePath(((DefaultMutableTreeNode) root.getChildAt(i)).getPath())); } }
void deleteNodeParent(DefaultMutableTreeNode parent) throws Exception { while (parent.getChildCount() != 0) { DefaultMutableTreeNode node = (DefaultMutableTreeNode) parent.getFirstChild(); deleteNodeParent(node); } deleteNode(parent); }
/** Expand the current node and return the list of leaves (MaterialVO objects). */ private ArrayList getComponents(DefaultMutableTreeNode node) { ArrayList list = new ArrayList(); for (int i = 0; i < node.getChildCount(); i++) list.addAll(getComponents((DefaultMutableTreeNode) node.getChildAt(i))); if (node.isLeaf()) list.add(node.getUserObject()); return list; }
public DomainDiagramTreeNode addSubDiagram(DomainDiagram diagram, DefaultTreeModel tree) { DomainDiagramTreeNode diagramNode = new DomainDiagramTreeNode(diagram, this.projectContext); this.subdiagramsNode.add(diagramNode); int index = subdiagramsNode.getChildCount() - 1; tree.nodesWereInserted(subdiagramsNode, new int[] {index}); return diagramNode; }
public void treeWillExpand(TreeExpansionEvent e) { // get the tree path which will be expanded TreePath path = e.getPath(); if (path == null) { return; } // get the directory at the node DefaultMutableTreeNode node = (DefaultMutableTreeNode) path.getLastPathComponent(); File selDir = (File) node.getUserObject(); // remove old entries if (node.getChildCount() > 0) { node.removeAllChildren(); } // get all the subdirectories File childDirs[] = selDir.listFiles(this); if (childDirs == null) { return; } // add the subdirectories Arrays.sort(childDirs); for (int i = 0; i < childDirs.length; i++) { if (childDirs[i].isHidden()) { if (showHidden) { node.add(new DefaultMutableTreeNode(childDirs[i])); } } else { node.add(new DefaultMutableTreeNode(childDirs[i])); } } }
public boolean restoreSelection(TreeSelection treeSelection) { if (treeSelection.isEmpty()) return false; DefaultMutableTreeNode root = (DefaultMutableTreeNode) myTreeModel.getRoot(); for (int i = 0; i < root.getChildCount(); i++) { TreeNode node = root.getChildAt(i); if (node instanceof MessageNode) { MessageNode messageNode = (MessageNode) node; String[] text = messageNode.getText(); if (text.length == 0) continue; if (Comparing.equal(treeSelection.mySelectedTarget, text[0])) { TreePath pathToSelect = new TreePath(messageNode.getPath()); for (Enumeration enumeration = messageNode.children(); enumeration.hasMoreElements(); ) { Object o = enumeration.nextElement(); if (o instanceof MessageNode) { messageNode = (MessageNode) o; if (Comparing.equal(treeSelection.mySelectedTask, text[0])) { pathToSelect = new TreePath(messageNode.getPath()); break; } } } TreeUtil.selectPath(myTree, pathToSelect); myTree.expandPath(pathToSelect); return true; } } } return false; }