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 static List<TreePath> collectExpandedPaths(final JTree tree, TreePath path) { final ArrayList<TreePath> result = new ArrayList<TreePath>(); if (!tree.isExpanded(path)) return result; final Object lastPathComponent = path.getLastPathComponent(); final TreeModel model = tree.getModel(); if (model.isLeaf(lastPathComponent)) { result.add(path); } else { boolean pathWasAdded = false; for (int i = model.getChildCount(lastPathComponent) - 1; i >= 0; i--) { final TreePath childPath = path.pathByAddingChild(model.getChild(lastPathComponent, i)); if (model.isLeaf(lastPathComponent)) { if (!pathWasAdded) { result.add(path); pathWasAdded = true; } } else if (tree.isExpanded(childPath)) { result.addAll(collectExpandedPaths(tree, childPath)); } else { if (!pathWasAdded) { result.add(path); pathWasAdded = true; } } } } return result; }
private static TreePath[] removeDuplicates(final TreePath[] paths) { final ArrayList<TreePath> result = new ArrayList<TreePath>(); for (final TreePath path : paths) { if (!result.contains(path)) result.add(path); } return result.toArray(new TreePath[result.size()]); }
public static ArrayList<TreeNode> childrenToArray(final TreeNode node) { final ArrayList<TreeNode> result = new ArrayList<TreeNode>(); for (int i = 0; i < node.getChildCount(); i++) { result.add(node.getChildAt(i)); } return result; }
public static TreePath getPathFromRoot(TreeNode node) { final ArrayList<TreeNode> path = new ArrayList<TreeNode>(); do { path.add(node); node = node.getParent(); } while (node != null); Collections.reverse(path); return new TreePath(path.toArray()); }
private Collection<EditorSchemeAttributeDescriptor> getOrderedDescriptors( @NotNull ColorAndFontOptions options) { ArrayList<EditorSchemeAttributeDescriptor> list = ContainerUtil.newArrayList(); for (EditorSchemeAttributeDescriptor description : options.getCurrentDescriptions()) { if (!description.getGroup().equals(myCategoryName)) continue; list.add(description); } Collections.sort(list, ATTR_COMPARATOR); return list; }
public void selectElements(ClassMember[] elements) { ArrayList<TreePath> selectionPaths = new ArrayList<TreePath>(); for (ClassMember element : elements) { MemberNode treeNode = myElementToNodeMap.get(element); if (treeNode != null) { selectionPaths.add(new TreePath(((DefaultMutableTreeNode) treeNode).getPath())); } } myTree.setSelectionPaths(selectionPaths.toArray(new TreePath[selectionPaths.size()])); }
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); }
public static TreePath[] selectMaximals(final TreePath[] paths) { if (paths == null) return new TreePath[0]; final TreePath[] noDuplicates = removeDuplicates(paths); final ArrayList<TreePath> result = new ArrayList<TreePath>(); for (final TreePath path : noDuplicates) { final ArrayList<TreePath> otherPaths = new ArrayList<TreePath>(Arrays.asList(noDuplicates)); otherPaths.remove(path); if (!isDescendants(path, otherPaths.toArray(new TreePath[otherPaths.size()]))) result.add(path); } return result.toArray(new TreePath[result.size()]); }
public static List<TreePath> collectSelectedPaths(final JTree tree, final TreePath treePath) { final ArrayList<TreePath> result = new ArrayList<TreePath>(); final TreePath[] selections = tree.getSelectionPaths(); if (selections != null) { for (TreePath selection : selections) { if (treePath.isDescendant(selection)) { result.add(selection); } } } return result; }
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); }
private List<ActionUrl> findActionsUnderSelection() { final ArrayList<ActionUrl> actions = new ArrayList<ActionUrl>(); final TreePath[] selectionPaths = myActionsTree.getSelectionPaths(); if (selectionPaths != null) { for (TreePath path : selectionPaths) { final ActionUrl selectedUrl = CustomizationUtil.getActionUrl(path, ActionUrl.MOVE); final ArrayList<String> selectedGroupPath = new ArrayList<String>(selectedUrl.getGroupPath()); final Object component = selectedUrl.getComponent(); if (component instanceof Group) { selectedGroupPath.add(((Group) component).getName()); for (ActionUrl action : mySelectedSchema.getActions()) { final ArrayList<String> groupPath = action.getGroupPath(); final int idx = Collections.indexOfSubList(groupPath, selectedGroupPath); if (idx > -1) { actions.add(action); } } } } } return actions; }
protected void clear(JComponent comp) { int nCompCount = comp.getComponentCount(); ArrayList aListComps = new ArrayList(); for (int i = 0; i < comp.getComponentCount(); i++) { Component compChild = comp.getComponent(i); if (compChild instanceof JComponent) { JComponent jcomp = (JComponent) compChild; if (jcomp instanceof JCheckBox || jcomp instanceof JTextField) aListComps.add(comp); else clear(jcomp); } } clear(aListComps); }
@NotNull public static <T> List<T> collectSelectedObjectsOfType(JTree tree, Class<T> clazz) { final TreePath[] selections = tree.getSelectionPaths(); if (selections != null) { final ArrayList<T> result = new ArrayList<T>(); for (TreePath selection : selections) { final DefaultMutableTreeNode node = (DefaultMutableTreeNode) selection.getLastPathComponent(); final Object userObject = node.getUserObject(); if (clazz.isInstance(userObject)) { //noinspection unchecked result.add((T) userObject); } } return result; } return Collections.emptyList(); }
private void restoreSelection(Pair<ElementNode, List<ElementNode>> pair) { List<ElementNode> selectedNodes = pair.second; DefaultMutableTreeNode root = getRootNode(); ArrayList<TreePath> toSelect = new ArrayList<TreePath>(); for (ElementNode node : selectedNodes) { DefaultMutableTreeNode treeNode = (DefaultMutableTreeNode) node; if (root.isNodeDescendant(treeNode)) { toSelect.add(new TreePath(treeNode.getPath())); } } if (!toSelect.isEmpty()) { myTree.setSelectionPaths(toSelect.toArray(new TreePath[toSelect.size()])); } ElementNode leadNode = pair.first; if (leadNode != null) { myTree.setLeadSelectionPath(new TreePath(((DefaultMutableTreeNode) leadNode).getPath())); } }
public void addToLabel(DataField txf) { m_aListTxfLabel.add(txf); }
/** * Write the file by writing the values from the labels, and the values list. * * @param strFile the file to be written. * @param aListLabels arraylist of texfields of labels. * @param aListValues arraylist of texfields of values. */ protected void writeFile( String strUser, String strFile, ArrayList aListLabels, ArrayList aListValues) { String strPath = FileUtil.openPath(strFile); String strLabel = ""; String strValue = ""; StringBuffer sbValues = new StringBuffer(); JTextField txfLabel = null; JTextField txfValue = null; boolean bNewFile = false; int nFDAMode = Util.getPart11Mode(); // if it's the part11 pnl and the mode is nonFDA, // then don't write the file for this panel // the other way is not true. if (this instanceof DisplayParentDirectory) { if ((isPart11Pnl() && nFDAMode == Util.NONFDA)) { return; } } if (strPath == null) { strPath = FileUtil.savePath(strFile); bNewFile = true; } if (strPath == null || aListLabels == null) return; if (aListValues == null) aListValues = new ArrayList(); // Get the list of the textfields for values and labels. int nLblSize = aListLabels.size(); int nValueSize = aListValues.size(); ArrayList<String> labelList = new ArrayList<String>(); // Get the value from each textfield, and add it to the buffer. for (int i = 0; i < nLblSize; i++) { txfLabel = (JTextField) aListLabels.get(i); txfValue = (i < nValueSize) ? (JTextField) aListValues.get(i) : null; strLabel = (txfLabel != null) ? txfLabel.getText() : null; strValue = (txfValue != null) ? txfValue.getText() : ""; // We need to be sure they don't have two data directories with // the same labels. Save the label list if we are writing to // the "data" file. if (strFile.indexOf("data") != -1) { if (labelList.contains(strLabel)) { Messages.postError( "The Data Directory specifications " + "must not have duplicate Label names. " + "The Label \"" + strLabel + "\" is duplicated. " + "Skipping the second instance. Please " + "specify a new Label."); continue; } else labelList.add(strLabel); } if (strLabel == null || strLabel.trim().length() <= 0 || strValue.equals(INFOSTR)) continue; // for user template tab, don't need to parse the value if (!(this instanceof DisplayTemplate)) strValue = getValue(strUser, strValue); strLabel = strLabel.trim(); if (strValue != null) strValue = strValue.trim(); // sbValues.append("\""); sbValues.append(strLabel); // sbValues.append("\" "); sbValues.append(File.pathSeparator); sbValues.append(strValue); sbValues.append("\n"); } if (Util.isPart11Sys()) writeAuditTrail(strPath, strUser, sbValues); // write the data to the file. BufferedWriter writer = WFileUtil.openWriteFile(strPath); WFileUtil.writeAndClose(writer, sbValues); // if it's a template file, then make it writable for everyone. if (bNewFile) { String strCmd = "chmod 755 "; if (this instanceof DisplayTemplate) strCmd = "chmod 777 "; if (Util.iswindows()) strPath = UtilB.windowsPathToUnix(strPath); String[] cmd = {WGlobal.SHTOOLCMD, WGlobal.SHTOOLOPTION, strCmd + strPath}; WUtil.runScriptInThread(cmd); } }
public void addToValue(DataField txf) { m_aListTxfValue.add(txf); }