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