/** * Overloads the left shift operator to provide an easy way to add * paths to a treePath.<p> * <b>WARNING:</b> this operation returns a new TreePath, not the original one.<p> * * @param self a TreePath * @param p an object to be added to the treePath. * @return same treePath, after the value was added to it. * @since 1.6.4 */ public static TreePath leftShift(TreePath self, Object p) { return self.pathByAddingChild(p); }
private boolean areSiblingsSelected(TreePath path) { TreePath parent = path.getParentPath(); if (parent == null) { return true; } Object node = path.getLastPathComponent(); Object parentNode = parent.getLastPathComponent(); int childCount = model.getChildCount(parentNode); for (int i = 0; i < childCount; i++) { Object childNode = model.getChild(parentNode, i); if (childNode == node) { continue; } if (!isPathSelected(parent.pathByAddingChild(childNode))) { return false; } } return true; }
private void expandAll(TreePath parent, boolean expand) { // Traverse children TreeNode node = (TreeNode) parent.getLastPathComponent(); if (node.getChildCount() >= 0) { for (Enumeration<? extends TreeNode> e = node.children(); e.hasMoreElements();) { TreeNode n = e.nextElement(); TreePath path = parent.pathByAddingChild(n); expandAll(path, expand); } } if (expand) { expandPath(parent); } else { collapsePath(parent); } } }
private void expandSubtree(TreePath path, boolean expand) { if (path == null) { TreePath selectionPath = getSelectionPath(); path = selectionPath == null ? new TreePath(treeModel.getRoot()) : selectionPath; } DefaultMutableTreeNode currentNode = (DefaultMutableTreeNode) path.getLastPathComponent(); Enumeration children = currentNode.children(); while (children.hasMoreElements()) { DefaultMutableTreeNode child = (DefaultMutableTreeNode) children.nextElement(); TreePath expandedPath = path.pathByAddingChild(child); expandSubtree(expandedPath, expand); } if (expand) { expandPath(path); } else if (path.getParentPath() != null) { collapsePath(path); } }
private void toggleRemoveSelection(TreePath path) { Stack stack = new Stack(); TreePath parent = path.getParentPath(); while (parent != null && !isPathSelected(parent)) { stack.push(parent); parent = parent.getParentPath(); } if (parent != null) { stack.push(parent); } else { super.removeSelectionPaths(new TreePath[]{path}); return; } while (!stack.isEmpty()) { TreePath temp = (TreePath) stack.pop(); TreePath peekPath = stack.isEmpty() ? path : (TreePath) stack.peek(); Object node = temp.getLastPathComponent(); Object peekNode = peekPath.getLastPathComponent(); int childCount = model.getChildCount(node); for (int i = 0; i < childCount; i++) { Object childNode = model.getChild(node, i); if (childNode != peekNode) { super.addSelectionPaths(new TreePath[]{temp.pathByAddingChild(childNode)}); } } } super.removeSelectionPaths(new TreePath[]{parent}); }
@Override public void treeExpanded(final TreeExpansionEvent event) { final TreePath treePath = event.getPath(); final Object expandedTreePathObject = treePath.getLastPathComponent(); if (!(expandedTreePathObject instanceof TreeNode)) { return; } final TreeNode expandedTreeNode = (TreeNode) expandedTreePathObject; if (expandedTreeNode.getChildCount() == 1) { final TreeNode descendantTreeNode = expandedTreeNode.getChildAt(0); if (descendantTreeNode.isLeaf()) { return; } final TreePath nextTreePath = treePath.pathByAddingChild(descendantTreeNode); tree.expandPath(nextTreePath); } }
nodesCheckingState.put(tp, cn); for (int i = 0 ; i < node.getChildCount() ; i++) { addSubtreeToCheckingStateTracking((DefaultMutableTreeNode) tp.pathByAddingChild(node.getChildAt(i)).getLastPathComponent()); parentCheckedNode.isSelected = false; for (int i = 0 ; i < parentNode.getChildCount() ; i++) { TreePath childPath = parentPath.pathByAddingChild(parentNode.getChildAt(i)); CheckedNode childCheckedNode = nodesCheckingState.get(childPath); DefaultMutableTreeNode node = (DefaultMutableTreeNode) tp.getLastPathComponent(); for (int i = 0 ; i < node.getChildCount() ; i++) { checkSubTree(tp.pathByAddingChild(node.getChildAt(i)), check);
/** * Constructs TreePath from Status String. * @param pathString * @return a TreePath, or null if there is an error. */ private TreePath generatePath(String pathString) { List<String> nodes = parsePathString(pathString); if (nodes == null) { return null; } Object obj = rootNode; TreePath treePath = new TreePath(obj); for (String node : nodes) { obj = searchNode(obj, node); if (obj == null) { return null; } treePath = treePath.pathByAddingChild(obj); } return treePath; }
protected void addMemberFormatter(ActionEvent evt) { final LevelInfo info = getSelectedLevel(evt); if (info == null) { return; } final MondrianGuiDef.MemberFormatter formatter = new MondrianGuiDef.MemberFormatter(); info.level.memberFormatter = formatter; TreePath parentPath = new TreePath(info.parentPathObjs); tree.setSelectionPath(parentPath.pathByAddingChild(formatter)); refreshTree(tree.getSelectionPath()); setTableCellFocus(0); }
protected void addKeyExp(ActionEvent evt) { final LevelInfo info = getSelectedLevel(evt); if (info == null) { return; } MondrianGuiDef.KeyExpression keyExp = new MondrianGuiDef.KeyExpression(); keyExp.expressions = new MondrianGuiDef.SQL[1]; // min 1 keyExp.expressions[0] = new MondrianGuiDef.SQL(); keyExp.expressions[0].dialect = "generic"; keyExp.expressions[0].cdata = ""; info.level.keyExp = keyExp; TreePath parentPath = new TreePath(info.parentPathObjs); tree.setSelectionPath(parentPath.pathByAddingChild(keyExp)); refreshTree(tree.getSelectionPath()); }
protected void addCaptionExp(ActionEvent evt) { final LevelInfo info = getSelectedLevel(evt); if (info == null) { return; } MondrianGuiDef.CaptionExpression captionExp = new MondrianGuiDef.CaptionExpression(); captionExp.expressions = new MondrianGuiDef.SQL[1]; // min 1 captionExp.expressions[0] = new MondrianGuiDef.SQL(); captionExp.expressions[0].dialect = "generic"; captionExp.expressions[0].cdata = ""; info.level.captionExp = captionExp; TreePath parentPath = new TreePath(info.parentPathObjs); tree.setSelectionPath(parentPath.pathByAddingChild(captionExp)); refreshTree(tree.getSelectionPath()); }
protected void addParentExp(ActionEvent evt) { final LevelInfo info = getSelectedLevel(evt); if (info == null) { return; } MondrianGuiDef.ParentExpression parentExp = new MondrianGuiDef.ParentExpression(); parentExp.expressions = new MondrianGuiDef.SQL[1]; // min 1 parentExp.expressions[0] = new MondrianGuiDef.SQL(); parentExp.expressions[0].dialect = "generic"; parentExp.expressions[0].cdata = ""; info.level.parentExp = parentExp; TreePath parentPath = new TreePath(info.parentPathObjs); tree.setSelectionPath(parentPath.pathByAddingChild(parentExp)); refreshTree(tree.getSelectionPath()); }
protected void addNameExp(ActionEvent evt) { final LevelInfo info = getSelectedLevel(evt); if (info == null) { return; } MondrianGuiDef.NameExpression nameExp = new MondrianGuiDef.NameExpression(); nameExp.expressions = new MondrianGuiDef.SQL[1]; // min 1 nameExp.expressions[0] = new MondrianGuiDef.SQL(); nameExp.expressions[0].dialect = "generic"; nameExp.expressions[0].cdata = ""; info.level.nameExp = nameExp; TreePath parentPath = new TreePath(info.parentPathObjs); tree.setSelectionPath(parentPath.pathByAddingChild(nameExp)); refreshTree(tree.getSelectionPath()); }
protected void addOrdinalExp(ActionEvent evt) { final LevelInfo info = getSelectedLevel(evt); if (info == null) { return; } MondrianGuiDef.OrdinalExpression ordinalExp = new MondrianGuiDef.OrdinalExpression(); ordinalExp.expressions = new MondrianGuiDef.SQL[1]; // min 1 ordinalExp.expressions[0] = new MondrianGuiDef.SQL(); ordinalExp.expressions[0].dialect = "generic"; ordinalExp.expressions[0].cdata = ""; info.level.ordinalExp = ordinalExp; TreePath parentPath = new TreePath(info.parentPathObjs); tree.setSelectionPath(parentPath.pathByAddingChild(ordinalExp)); refreshTree(tree.getSelectionPath()); }
/** * Expand the given tree to the given level, starting from the given node * and path. * * @param tree The tree to be expanded * @param node The node to start from * @param path The path to start from * @param level The number of levels to expand to */ private static void expandNode(final JTree tree, final TreeNode node, final TreePath path, final int level) { if (level <= 0) { return; } tree.expandPath(path); for (int i = 0; i < node.getChildCount(); ++i) { final TreeNode childNode = node.getChildAt(i); expandNode(tree, childNode, path.pathByAddingChild(childNode), level - 1); } }
protected void addRole(ActionEvent evt) { MondrianGuiDef.Schema schema = (MondrianGuiDef.Schema) tree.getModel().getRoot(); MondrianGuiDef.Role role = new MondrianGuiDef.Role(); role.name = ""; role.schemaGrants = new MondrianGuiDef.SchemaGrant[0]; // add cube to schema role.name = getNewName( getResourceConverter().getString( "schemaExplorer.newRole.title", "New Role"), schema.roles); NodeDef[] temp = schema.roles; schema.roles = new MondrianGuiDef.Role[temp.length + 1]; for (int _i = 0; _i < temp.length; _i++) { schema.roles[_i] = (MondrianGuiDef.Role) temp[_i]; } schema.roles[schema.roles.length - 1] = role; tree.setSelectionPath( (new TreePath(model.getRoot())).pathByAddingChild( role)); refreshTree(tree.getSelectionPath()); setTableCellFocus(0); }
protected void addParameter(ActionEvent evt) { MondrianGuiDef.Schema schema = (MondrianGuiDef.Schema) tree.getModel().getRoot(); MondrianGuiDef.Parameter parameter = new MondrianGuiDef.Parameter(); parameter.name = ""; // set the required fields parameter.name = getNewName( getResourceConverter().getString( "schemaExplorer.newParameter.title", "New Parameter"), schema.parameters); // set the default values parameter.type = "String"; parameter.modifiable = Boolean.TRUE; NodeDef[] temp = schema.parameters; schema.parameters = new MondrianGuiDef.Parameter[temp.length + 1]; for (int _i = 0; _i < temp.length; _i++) { schema.parameters[_i] = (MondrianGuiDef.Parameter) temp[_i]; } schema.parameters[schema.parameters.length - 1] = parameter; tree.setSelectionPath( (new TreePath(model.getRoot())).pathByAddingChild( parameter)); refreshTree(tree.getSelectionPath()); setTableCellFocus(0); }
protected void addUserDefinedFunction(ActionEvent evt) { MondrianGuiDef.Schema schema = (MondrianGuiDef.Schema) tree.getModel().getRoot(); MondrianGuiDef.UserDefinedFunction udf = new MondrianGuiDef.UserDefinedFunction(); udf.name = ""; udf.name = getNewName( getResourceConverter().getString( "schemaExplorer.newUserDefinedFunction.title", "New User defined Function"), schema.userDefinedFunctions); NodeDef[] temp = schema.userDefinedFunctions; schema.userDefinedFunctions = new MondrianGuiDef.UserDefinedFunction[temp.length + 1]; for (int _i = 0; _i < temp.length; _i++) { schema.userDefinedFunctions[_i] = (MondrianGuiDef.UserDefinedFunction) temp[_i]; } schema.userDefinedFunctions[schema.userDefinedFunctions.length - 1] = udf; tree.setSelectionPath( new TreePath(model.getRoot()).pathByAddingChild( udf)); refreshTree(tree.getSelectionPath()); setTableCellFocus(0); }
protected void addVirtualCube(ActionEvent evt) { MondrianGuiDef.Schema schema = (MondrianGuiDef.Schema) tree.getModel().getRoot(); MondrianGuiDef.VirtualCube cube = new MondrianGuiDef.VirtualCube(); cube.name = ""; cube.dimensions = new MondrianGuiDef.VirtualCubeDimension[0]; cube.measures = new MondrianGuiDef.VirtualCubeMeasure[0]; cube.calculatedMembers = new MondrianGuiDef.CalculatedMember[0]; cube.enabled = Boolean.TRUE; // add cube to schema cube.name = getNewName( getResourceConverter().getString( "schemaExplorer.newVirtualCube.title", "New Virtual Cube"), schema.virtualCubes); NodeDef[] temp = schema.virtualCubes; schema.virtualCubes = new MondrianGuiDef.VirtualCube[temp.length + 1]; for (int i = 0; i < temp.length; i++) { schema.virtualCubes[i] = (MondrianGuiDef.VirtualCube) temp[i]; } schema.virtualCubes[schema.virtualCubes.length - 1] = cube; tree.setSelectionPath( new TreePath(model.getRoot()).pathByAddingChild( cube)); refreshTree(tree.getSelectionPath()); setTableCellFocus(0); }
protected void addProperty(ActionEvent evt) { final LevelInfo info = getSelectedLevel(evt); if (info == null) { return; } MondrianGuiDef.Property property = new MondrianGuiDef.Property(); property.name = ""; if (info.level.properties == null) { info.level.properties = new MondrianGuiDef.Property[0]; } property.name = getNewName( getResourceConverter().getString( "schemaExplorer.newProperty.title", "New Property"), info.level.properties); NodeDef[] temp = info.level.properties; info.level.properties = new MondrianGuiDef.Property[temp.length + 1]; for (int i = 0; i < temp.length; i++) { info.level.properties[i] = (MondrianGuiDef.Property) temp[i]; } info.level.properties[info.level.properties.length - 1] = property; TreePath parentPath = new TreePath(info.parentPathObjs); tree.setSelectionPath(parentPath.pathByAddingChild(property)); refreshTree(tree.getSelectionPath()); setTableCellFocus(0); }