Java Code Examples for javax.swing.tree.DefaultMutableTreeNode#getParent()

/**
 * Removes the selected module in the tvProcessingList from the list
 */
private void removeModule() {
  DefaultMutableTreeNode selected = getSelectedItem(tvProcessing);
  if (selected == null)
    return;

  if (selected instanceof DPPModuleTreeNode) {
    DefaultMutableTreeNode parent = (DefaultMutableTreeNode) selected.getParent();
    if (parent instanceof DPPMSLevelTreeNode && ((DPPMSLevelTreeNode) parent).isEnabled()) {
      parent.remove(selected);
      logger.finest("Removed module " + ((DPPModuleTreeNode) selected).getModule().getName()
          + " from processing list.");
    }
  } else {
    logger.finest("Cannot remove item " + selected.toString() + " from processing list.");
  }
  ((DefaultTreeModel) tvProcessing.getModel()).reload();
  expandAllNodes(tvProcessing);
}
 

@Test
public void testCreatePackagesTree() throws Exception {
  //given
  TreeSet<String> packages = new TreeSet<>(Arrays.asList("a", "a.b", "c", "c.d"));
  HashMap<ClassLikeFilter.Clazz, DefaultMutableTreeNode> map = new HashMap<>();
  final DefaultMutableTreeNode root = new DefaultMutableTreeNode(new ClassLikeFilter.Clazz("root"));

  //when
  filter.createPackagesTree(packages, map, root);

  //then
  assertEquals(map.size(), 4);
  assertTrue(map.containsKey(new ClassLikeFilter.Clazz("a")));
  assertTrue(map.containsKey(new ClassLikeFilter.Clazz("a.b")));
  assertTrue(map.containsKey(new ClassLikeFilter.Clazz("c")));
  assertTrue(map.containsKey(new ClassLikeFilter.Clazz("c.d")));
  final DefaultMutableTreeNode child = map.get(new ClassLikeFilter.Clazz("a.b"));
  final DefaultMutableTreeNode parent = map.get(new ClassLikeFilter.Clazz("a"));
  System.out.println(parent);
  final TreeNode parent1 = child.getParent();
  assertEquals(parent1, parent);
}
 

public DefaultMutableTreeNode getSelectedServerNode() {
    DefaultMutableTreeNode treeNode = (DefaultMutableTreeNode) databaseTree.getLastSelectedPathComponent();
    if (treeNode != null) {
        Object userObject = treeNode.getUserObject();
        if (userObject instanceof MongoCollection) {
            return (DefaultMutableTreeNode) treeNode.getParent().getParent();
        }

        if (userObject instanceof Database) {
            return (DefaultMutableTreeNode) treeNode.getParent();
        }

        if (userObject instanceof DatabaseServer) {
            return treeNode;
        }
    }
    return null;
}
 

@Override
public final void dragGestureRecognized(final DragGestureEvent dge) {
  // final TreePath path = tree.getSelectionPath();
  final TreePath path = tree.getPathForLocation(dge.getDragOrigin().x, dge.getDragOrigin().y);

  if (path != null) {
    draggedNode = (DefaultMutableTreeNode) path.getLastPathComponent();
    draggedNodeParent = (DefaultMutableTreeNode) draggedNode.getParent();
    if (drawImage) {
      final Rectangle pathBounds = tree.getPathBounds(path); // getpathbounds of selectionpath
      final JComponent lbl =
          (JComponent) tree.getCellRenderer().getTreeCellRendererComponent(tree, draggedNode,
              false, tree.isExpanded(path),
              ((DefaultTreeModel) tree.getModel()).isLeaf(path.getLastPathComponent()), 0, false);// returning
                                                                                                  // the
                                                                                                  // label
      lbl.setBounds(pathBounds);// setting bounds to lbl
      image =
          new BufferedImage(lbl.getWidth(), lbl.getHeight(),
              java.awt.image.BufferedImage.TYPE_INT_ARGB_PRE);// buffered image reference passing
                                                              // the label's ht and width
      final Graphics2D graphics = image.createGraphics();// creating the graphics for buffered
                                                         // image
      graphics.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.5f)); // Sets
                                                                                        // the
                                                                                        // Composite
                                                                                        // for the
                                                                                        // Graphics2D
                                                                                        // context
      lbl.setOpaque(false);
      lbl.paint(graphics); // painting the graphics to label
      graphics.dispose();
    }
    dragSource.startDrag(dge, DragSource.DefaultMoveNoDrop, image, new Point(0, 0),
        new TransferableNode(draggedNode), this);
  }
}
 

private void reload(@Nullable final DefaultMutableTreeNode rootToReload) {
  final DefaultTreeModel treeModel = (DefaultTreeModel)myTree.getModel();
  if (rootToReload != null && rootToReload != treeModel.getRoot()) {
    final List<TreePath> treePaths = TreeUtil.collectExpandedPaths(myTree, new TreePath(rootToReload.getPath()));
    final List<TreePath> selectionPaths = TreeUtil.collectSelectedPaths(myTree, new TreePath(rootToReload.getPath()));
    final TreePath path = new TreePath(rootToReload.getPath());
    final boolean wasCollapsed = myTree.isCollapsed(path);
    final Runnable runnable = new Runnable() {
      @Override
      public void run() {
        if (!isTreeShowing() || rootToReload.getParent() == null) return;
        TreeUtil.sort(rootToReload, getNodeComparator());
        treeModel.reload(rootToReload);
        if (!wasCollapsed) {
          myTree.collapsePath(path);
          for (TreePath treePath : treePaths) {
            myTree.expandPath(treePath);
          }
          for (TreePath selectionPath : selectionPaths) {
            TreeUtil.selectPath(myTree, selectionPath);
          }
        }
      }
    };
    if (ApplicationManager.getApplication().isUnitTestMode()) {
      runnable.run();
    }
    else {
      SwingUtilities.invokeLater(runnable);
    }
  }
  else {
    TreeUtil.sort(treeModel, getNodeComparator());
    treeModel.reload();
  }
}
 

/**
 * Recursively create the path string for the given node
 * 
 * @param node The node
 * @return The path string
 * @see #createPathString(TreePath)
 */
private static String createPathString(DefaultMutableTreeNode node)
{
    StringBuilder sb = new StringBuilder();
    TreeNode parent = node.getParent();
    if (parent != null)
    {
        if (parent instanceof DefaultMutableTreeNode)
        {
            DefaultMutableTreeNode parentNode =
                (DefaultMutableTreeNode)parent;
            sb.append(createPathString(parentNode));
            sb.append(".");
        }
        else
        {
            logger.warning("Unexpected node type: "+parent.getClass());
        }
    }
    Object userObject = node.getUserObject();
    if (userObject != null)
    {
        if (userObject instanceof NodeEntry)
        {
            NodeEntry nodeEntry = (NodeEntry)userObject;
            sb.append(nodeEntry.getName());
        }
        else
        {
            logger.warning(
                "Unexpected user object type: "+userObject.getClass());
        }
    }
    return sb.toString();
}
 

/**
 * Item selected.
 *
 * @param node the node
 * @param userObject the user object
 */
@Override
public void itemSelected(DefaultMutableTreeNode node, Object userObject) {
    SelectedSymbol selectedSymbol = SelectedSymbol.getInstance();

    // Individual symbol selected
    Symbolizer symbolizer = (Symbolizer) userObject;

    if (node != null) {
        DefaultMutableTreeNode parent = (DefaultMutableTreeNode) node.getParent();
        if (parent != null) {
            selectedSymbol.setSymbolizer(symbolizer);
        }
    }
}
 

@Nonnull
private List<DefaultMutableTreeNode> getPresentationForCommits(@Nonnull final Project project,
                                                               @Nonnull List<? extends VcsFullCommitDetails> commits,
                                                               int commitsNum) {
  Function<VcsFullCommitDetails, DefaultMutableTreeNode> commitToNode = new Function<VcsFullCommitDetails, DefaultMutableTreeNode>() {
    @Override
    public DefaultMutableTreeNode fun(VcsFullCommitDetails commit) {
      return new CommitNode(project, commit);
    }
  };
  List<DefaultMutableTreeNode> childrenToShown = new ArrayList<DefaultMutableTreeNode>();
  for (int i = 0; i < commits.size(); ++i) {
    if (i >= commitsNum) {
      final VcsLinkedTextComponent moreCommitsLink = new VcsLinkedTextComponent("<a href='loadMore'>...</a>", new VcsLinkListener() {
        @Override
        public void hyperlinkActivated(@Nonnull DefaultMutableTreeNode sourceNode, @Nonnull MouseEvent event) {
          TreeNode parent = sourceNode.getParent();
          if (parent instanceof RepositoryNode) {
            addMoreCommits((RepositoryNode)parent);
          }
        }
      });
      childrenToShown.add(new TextWithLinkNode(moreCommitsLink));
      break;
    }
    childrenToShown.add(commitToNode.fun(commits.get(i)));
  }
  return childrenToShown;
}
 

private void updateNode(Object arg) {
    UpdateElementEvent event = (UpdateElementEvent) arg;
    if(event.getElement() instanceof GScreen){
        //This function update the position in the tree
        //but Screens never needs such of feature. 
        return;
    }
    int i = this.getIndex(event.getElement());
    DefaultMutableTreeNode node = searchNode(event.getElement());
    DefaultMutableTreeNode parent = (DefaultMutableTreeNode) node.getParent();
    parent.insert(node, i);
    jTree2.updateUI();
}
 

/**
 * Deletes the selected node from the tree and removes the corresponding entry from the report.
 * @param evt
 */
private void btnDeleteActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_btnDeleteActionPerformed
    selected = (DefaultMutableTreeNode) reportTree.getLastSelectedPathComponent();
    if (selected == null) {
        //Nothing is selected
        return;
    }
    //If it's a host
    if (selected.getPath().length == 2) {
        String hostname = selected.toString();
        int toDelete = this.getIndexOfHost(hostname);
        if (toDelete == -1) {
            return;
        }
        report.getReports().remove(toDelete);
    } else if (selected.getPath().length == 3) { //If it's a rule
        String host = selected.getParent().toString();
        String rule = selected.toString();
        int hostNum = this.getIndexOfHost(host);
        int ruleNum = this.getIndexOfRule(hostNum, rule);
        if (hostNum == -1 || ruleNum == -1) {
            return;
        }
        report.getReports().get(hostNum).getMatchedRules().remove(ruleNum);
    }
    MutableTreeNode parent = (MutableTreeNode) selected.getParent();
    int index = parent.getIndex(selected);
    parent.remove(selected);
    model.nodesWereRemoved(parent, new int[]{index}, new Object[]{selected});
    reportTree.setModel(model);

}
 

@javax.annotation.Nullable
private LibraryOrderEntry getSelectedLibrary() {
  final AbstractProjectViewPane viewPane = getCurrentProjectViewPane();
  DefaultMutableTreeNode node = viewPane != null ? viewPane.getSelectedNode() : null;
  if (node == null) return null;
  DefaultMutableTreeNode parent = (DefaultMutableTreeNode)node.getParent();
  if (parent == null) return null;
  Object userObject = parent.getUserObject();
  if (userObject instanceof LibraryGroupNode) {
    userObject = node.getUserObject();
    if (userObject instanceof NamedLibraryElementNode) {
      NamedLibraryElement element = ((NamedLibraryElementNode)userObject).getValue();
      OrderEntry orderEntry = element.getOrderEntry();
      return orderEntry instanceof LibraryOrderEntry ? (LibraryOrderEntry)orderEntry : null;
    }
    PsiDirectory directory = ((PsiDirectoryNode)userObject).getValue();
    VirtualFile virtualFile = directory.getVirtualFile();
    Module module = (Module)((AbstractTreeNode)((DefaultMutableTreeNode)parent.getParent()).getUserObject()).getValue();

    if (module == null) return null;
    ModuleFileIndex index = ModuleRootManager.getInstance(module).getFileIndex();
    OrderEntry entry = index.getOrderEntryForFile(virtualFile);
    if (entry instanceof LibraryOrderEntry) {
      return (LibraryOrderEntry)entry;
    }
  }

  return null;
}
 

public DefaultMutableTreeNode getRemainingExpression(PsiExpression expressionToBeRemoved) {
    DefaultMutableTreeNode newRoot = new DefaultMutableTreeNode();
    processExpression(newRoot, completeExpression);
    DefaultMutableTreeNode leaf = newRoot.getFirstLeaf();
    while (leaf != null) {
        PsiExpression expression = (PsiExpression) leaf.getUserObject();
        if (expression.equals(expressionToBeRemoved)) {
            DefaultMutableTreeNode parent = (DefaultMutableTreeNode) leaf.getParent();
            if (parent != null) {
                DefaultMutableTreeNode grandParent = (DefaultMutableTreeNode) parent.getParent();
                DefaultMutableTreeNode sibling = null;
                if (leaf.getNextSibling() != null) {
                    sibling = leaf.getNextSibling();
                } else if (leaf.getPreviousSibling() != null) {
                    sibling = leaf.getPreviousSibling();
                }
                if (grandParent != null) {
                    int parentIndex = grandParent.getIndex(parent);
                    grandParent.remove(parent);
                    grandParent.insert(sibling, parentIndex);
                } else {
                    newRoot = sibling;
                }
            } else {
                newRoot = null;
            }
            break;
        }
        leaf = leaf.getNextLeaf();
    }
    return newRoot;
}
 

/**
 * 
 * @param root
 * @return boolean bad leaves were returned
 */
private boolean removeBadLeaves(DefaultMutableTreeNode root) {

	// no bad leaves yet
	boolean badLeaves = false;

	// reference first leaf
	DefaultMutableTreeNode leaf = root.getFirstLeaf();

	// if leaf is root then its the only node
	if (leaf.isRoot())
		return false;

	int leafCount = root.getLeafCount(); // this get method changes if in for loop so have to define outside of it
	for (int i = 0; i < leafCount; i++) {

		DefaultMutableTreeNode nextLeaf = leaf.getNextLeaf();

		// if it does not start with the text then snip it off its parent
		if (!filter.accepts(filterText, leaf.getUserObject().toString())) {
			DefaultMutableTreeNode parent = (DefaultMutableTreeNode) leaf.getParent();

			if (parent != null)
				parent.remove(leaf);

			badLeaves = true;
		}
		leaf = nextLeaf;
	}
	return badLeaves;
}
 

private void setSelected(final DefaultMutableTreeNode aRootNode, final Boolean isSelected, final boolean aRecursiveSelection) {
    //change the direct selection-state of the appropriate leaf node
    visitAll(aRootNode, (aValue, aNode) -> {
        if (aRecursiveSelection || aValue.equals(aRootNode.getUserObject())) {
            if (aValue instanceof SelectableWrapper) {
                SelectableWrapper theWrapper = (SelectableWrapper) aValue;

                if (isSelected == null) {
                    theWrapper.invertSelection();
                } else {
                    theWrapper.setSelected(isSelected);
                }

                return true;
            }

            return false;
        }

        return !aRecursiveSelection;
    });

    //check if the selection state of main nodes is affected indirectly by
    //changing selection state of leaf nodes
    if (aRootNode.isLeaf() && aRootNode.getUserObject() instanceof SelectableWrapper && ((SelectableWrapper) aRootNode.getUserObject()).getValue() instanceof TableEntry) {
        boolean allSelected = true;
        DefaultMutableTreeNode theMainNode = (DefaultMutableTreeNode) aRootNode.getParent();

        for (int i = 0; (allSelected && (i < theMainNode.getChildCount())); i++) {
            allSelected &= (((SelectableWrapper) (((DefaultMutableTreeNode) theMainNode.getChildAt(i)).getUserObject())).isSelected());
        }

        SelectableWrapper theMainWrapper = (SelectableWrapper) theMainNode.getUserObject();
        if (theMainWrapper.isSelected() != allSelected) {
            setSelected(theMainNode, allSelected, false);
        }
    }
}
 

/**
 * Create the PopupMenu actions correlating to a specific tree node.
 *
 * @param aNode	  - the node
 * @param aMenu	  - the menu to add the actions to
 * @param aRecursive - recursive
 */
private void initializeActionsFor(final DefaultMutableTreeNode aNode,
								  JPopupMenu aMenu, boolean aRecursive) {

	Object theUserObject = aNode.getUserObject();

	if (!aRecursive) {
		JMenuItem theExpandAllItem = new JMenuItem();
		theExpandAllItem.setText(getResourceHelper().getFormattedText(
				ERDesignerBundle.EXPANDALL));
		theExpandAllItem.addActionListener(e -> expandOrCollapseAllChildrenOfNode(new TreePath(aNode
                   .getPath()), true));
		aMenu.add(theExpandAllItem);

		JMenuItem theCollapseAllItem = new JMenuItem();
		theCollapseAllItem.setText(getResourceHelper().getFormattedText(
				ERDesignerBundle.COLLAPSEALL));
		theCollapseAllItem.addActionListener(e -> expandOrCollapseAllChildrenOfNode(new TreePath(aNode
                   .getPath()), false));

		aMenu.add(theCollapseAllItem);
		aMenu.addSeparator();
	}

	List<ModelItem> theItemList = new ArrayList<>();
	if (theUserObject instanceof ModelItem) {
		theItemList.add((ModelItem) theUserObject);
		ContextMenuFactory.addActionsToMenu(ERDesignerComponent.getDefault().getEditor(), aMenu, theItemList);
	}

	if (aNode.getParent() != null) {
		initializeActionsFor((DefaultMutableTreeNode) aNode.getParent(),
				aMenu, true);
	}
}
 

public void expandTreeToDepth(DefaultMutableTreeNode node, int depth, String userId, List<ListOptionSerialized> blankRestrictedTools, List<String> accessAdminNodeIds, boolean onlyAccessNodes, boolean shopping, boolean shoppingPeriodTool, String filterSearch){
	projectLogic.addChildrenNodes(node, userId, blankRestrictedTools, onlyAccessNodes, accessAdminNodeIds, shopping, shoppingPeriodTool);
	//set expand flag to true so to not look for children again:
	((NodeModel) node.getUserObject()).setAddedDirectChildrenFlag(true);
	getTree().getTreeState().expandNode(node);
	if(depth > 0){
		//recursive function stopper:
		int newDepth = depth - 1;
		//count down backwards since we could be deleting these children nodes
		for(int i = node.getChildCount() - 1; i >= 0; i--){
			expandTreeToDepth((DefaultMutableTreeNode) node.getChildAt(i), newDepth, userId, blankRestrictedTools, accessAdminNodeIds, onlyAccessNodes, shopping, shoppingPeriodTool, filterSearch);
		}
	}else{
		//make sure all children are collapsed and filter out the ones that need to be filtered
		//count down backwards since we could be deleting these children nodes
		for(int i = node.getChildCount() - 1; i >= 0; i--){
			getTree().getTreeState().collapseNode(node.getChildAt(i));
			String nodeTitle = ((NodeModel) ((DefaultMutableTreeNode) node.getChildAt(i)).getUserObject()).getNode().description.toLowerCase();
			if(filterSearch != null && !"".equals(filterSearch.trim()) && !nodeTitle.contains(filterSearch.toLowerCase())){
				//delete this child:
				node.remove(i);
			}
		}
	}
	//check if all of the children have been removed (but don't delete root node)
	if(node.getParent() != null && node.getChildCount() == 0){
		((DefaultMutableTreeNode) node.getParent()).remove(node);
	}
}
 

public boolean canPerformAction(DNDTree target, DefaultMutableTreeNode dragged_node, int action, Point location) {

		/* //debug:
		Utils.log2(DnDConstants.ACTION_COPY + " " + DnDConstants.ACTION_COPY_OR_MOVE + " " + DnDConstants.ACTION_LINK + " " + DnDConstants.ACTION_MOVE + " " + DnDConstants.ACTION_NONE + " " + DnDConstants.ACTION_REFERENCE);
		Utils.log2("action: " + action);
		*/



		// prevent drags from non-tree components
		if (null == dragged_node) return false;
		// Can't drop onto a TemplateTree
		if (target instanceof TemplateTree) {
			return false;
		}
		// Can't drag a node that contains a Project!
		if (dragged_node.getUserObject() instanceof ProjectThing && ((ProjectThing)dragged_node.getUserObject()).getObject() instanceof Project) {
			return false;
		}
		// Can't drag basic object nodes from a template tree RECONSIDERED, I like it even if it looks inconsistent (but types are types!)
		/*
		if (dragged_node.getUserObject() instanceof TemplateThing && project.isBasicType(((Thing)dragged_node.getUserObject()).getType())) {
			return false;
		}
		*/

		// else, the target has to be not null
		TreePath pathTarget = target.getPathForLocation(location.x, location.y);
		if (pathTarget == null) {
			target.setSelectionPath(null);
			return false;
		}

		/* // debug
		if (action == DnDConstants.ACTION_COPY) {
			Utils.log("can drop: Action copy");
		} else if (action == DnDConstants.ACTION_MOVE) {
			Utils.log("can drop: Action move");
		} else {
			Utils.log("can drop: Unexpected action: " + action);
		}
		*/

		target.setSelectionPath(pathTarget);
		DefaultMutableTreeNode parent_node = (DefaultMutableTreeNode)pathTarget.getLastPathComponent();
		Object parent_ob = parent_node.getUserObject(); // can be a Thing or an Attribute
		Thing child_thing = (Thing)dragged_node.getUserObject();

		if (DnDConstants.ACTION_MOVE == action || DnDConstants.ACTION_COPY == action) {
			if (parent_ob instanceof ProjectThing) {
				ProjectThing parent_thing = (ProjectThing)parent_ob;

				// TODO: check if the parent/parent/parent/.../parent of the dragged thing can have such parent as child, and autocreate them (but not for basic things though, or only if there is no confusion possible)

				// check if it's allowed to give to this parent such a child:
				if (!parent_thing.uniquePathExists(child_thing.getType()) && !parent_thing.canHaveAsChild(child_thing)) {
					//Utils.log("Not possible.");
					return false;
				}
				// enable to drop:
				// - any of the leafs in the template, including the root, to the project tree
				// disable to drop:
				// - the root leaf of the project tree
				// - the leaf that is going to be dropped into itself or any of its descendants.
				if (parent_node == dragged_node.getParent() || dragged_node.isNodeDescendant(parent_node)) {
					//Utils.log("preventing dragging onto itself or any of the self children.");
					return false;
				} else {
					return true;
				}
			}
		}

		// default:
		return false;
	}
 

@Override public void drop(DropTargetDropEvent dtde) {
  // System.out.println("drop");
  // if (!isWebStart()) {
  //   try {
  //     draggingObject = dtde.getTransferable().getTransferData(FLAVOR);
  //   } catch (Exception ex) {
  //     rejectDrag(dtde);
  //     return;
  //   }
  // } else {
  //   draggingObject = getSelectionPath().getLastPathComponent();
  // }
  Object draggingObject = getSelectionPath().getLastPathComponent();
  Point pt = dtde.getLocation();
  TreePath path = getPathForLocation(pt.x, pt.y);
  if (Objects.isNull(path) || !(draggingObject instanceof MutableTreeNode)) {
    dtde.dropComplete(false);
    return;
  }
  // System.out.println("drop path is " + path);
  MutableTreeNode draggingNode = (MutableTreeNode) draggingObject;
  DefaultMutableTreeNode targetNode = (DefaultMutableTreeNode) path.getLastPathComponent();
  if (targetNode.equals(draggingNode)) {
    // Cannot move the node to the node itself
    dtde.dropComplete(false);
    return;
  }
  dtde.acceptDrop(DnDConstants.ACTION_MOVE);

  DefaultTreeModel model = (DefaultTreeModel) getModel();
  model.removeNodeFromParent(draggingNode);

  TreeNode parent = targetNode.getParent();
  if (parent instanceof MutableTreeNode && targetNode.isLeaf()) {
    model.insertNodeInto(draggingNode, (MutableTreeNode) parent, parent.getIndex(targetNode));
  } else {
    model.insertNodeInto(draggingNode, targetNode, targetNode.getChildCount());
  }
  dtde.dropComplete(true);

  dropTargetNode = null;
  draggedNode = null;
  repaint();
}
 

/** Removes the item. */
public void removeItem() {
    if (symbolTree == null) {
        return;
    }

    TreePath path = symbolTree.getSelectionPath();

    if (path == null) {
        return;
    }

    DefaultMutableTreeNode lastNode = (DefaultMutableTreeNode) path.getLastPathComponent();
    Object obj = lastNode.getUserObject();

    // CHECKSTYLE:OFF
    Object oldValueObj = sldWriter.encodeSLD(null, SelectedSymbol.getInstance().getSld());
    // CHECKSTYLE:ON

    if (obj instanceof NamedLayer) {
        SelectedSymbol.getInstance().removeUserNamedLayer((NamedLayer) obj);
        removeTreeNode(lastNode);
    } else if (obj instanceof UserLayer) {
        SelectedSymbol.getInstance().removeUserNamedLayer((UserLayer) obj);
        removeTreeNode(lastNode);
    } else if (obj instanceof Style) {
        SelectedSymbol.getInstance().removeStyle((Style) obj);
        removeTreeNode(lastNode);
    } else if (obj instanceof FeatureTypeStyle) {
        SelectedSymbol.getInstance().removeFeatureTypeStyle((FeatureTypeStyle) obj);
        removeTreeNode(lastNode);
    } else if (obj instanceof Rule) {
        SelectedSymbol.getInstance().removeRule((Rule) obj);
        removeTreeNode(lastNode);
    } else if (obj instanceof Symbolizer) {
        DefaultMutableTreeNode parentNode = (DefaultMutableTreeNode) lastNode.getParent();
        if (parentNode != null) {
            if (parentNode.getUserObject() instanceof RasterSymbolizer) {
                SelectedSymbol.getInstance()
                        .removeRasterImageOutline(
                                (RasterSymbolizer) parentNode.getUserObject());
            } else {
                SelectedSymbol.getInstance().removeSymbolizer((Symbolizer) obj);
            }
            removeTreeNode(lastNode);
        }
    } else {
        return;
    }

    SLDTreeManager.getInstance().rebuildTree((SLDTree) sldTree);

    // Re-render the symbol
    if (renderList != null) {
        for (RenderSymbolInterface render : renderList) {
            render.renderSymbol();
        }
    }

    Object newValueObj = sldWriter.encodeSLD(null, SelectedSymbol.getInstance().getSld());

    UndoManager.getInstance()
            .addUndoEvent(
                    new UndoEvent(
                            sldTree.getUndoObject(),
                            getClass().getName(),
                            oldValueObj,
                            newValueObj));
}
 

/**
 * Tests if the removal is valid and then removes the path from the constraint
 *
 * @param e The action event
 */
@Override
@SuppressWarnings("unchecked")
public void actionPerformed(ActionEvent e) {
	// If there is nothing seleceted then just do nothing
	if (_theFrame.getInfoTreeUI().getInfoTree().isSelectionEmpty()) {
		return;
	}

	// If we're currently synced with a db, give the user the chance to
	// cancel operation
	if (_theFrame.getMModel().isSynced()) {
		int choice = JOptionPane.showConfirmDialog(_theFrame,
				"Warning: this sketch is currently synced with a db; continue and break synchronization?",
				"Warning!", JOptionPane.OK_CANCEL_OPTION, JOptionPane.WARNING_MESSAGE);

		if (choice == JOptionPane.CANCEL_OPTION) {
			return;
		}
	}

	// Get currently selected object
	DefaultMutableTreeNode curSelected = (DefaultMutableTreeNode) _theFrame.getInfoTreeUI().getInfoTree()
			.getSelectionPath().getLastPathComponent();

	// Selection is a constraint
	if (curSelected instanceof ModelPath) {
		ModelConstraint<F, GM, M, N, E> curConstraint = (ModelConstraint<F, GM, M, N, E>) curSelected.getParent();
		ArrayList<ModelPath<F, GM, M, N, E>> tempPaths = new ArrayList<>();

		tempPaths.remove(curSelected);

		boolean valid = false;

		if (curConstraint instanceof SumConstraint) {
			valid = _theFrame.getMModel().isSumConstraint(tempPaths);

			// Replace previous path array list
			if (valid) {
				((SumConstraint<F, GM, M, N, E>) curConstraint).setPaths(tempPaths);
			}
		} else if (curConstraint instanceof ProductConstraint) {
			valid = _theFrame.getMModel().isProductConstraint(tempPaths);

			// Replace previous path array list
			if (valid) {
				((ProductConstraint<F, GM, M, N, E>) curConstraint).setPaths(tempPaths);
			}
		} else if (curConstraint instanceof CommutativeDiagram) {
			valid = _theFrame.getMModel().isCommutativeDiagram(tempPaths);

			// Replace previous path array list
			if (valid) {
				((CommutativeDiagram<F, GM, M, N, E>) curConstraint).setPaths(tempPaths);
			}
		} else {
			JOptionPane.showMessageDialog(_theFrame,
					"You don't have a path selected that can be removed. \nPlease select another path and try again.",
					"No ModelConstraint Selected", JOptionPane.ERROR_MESSAGE);

			return;
		}

		if (valid) {
			ModelConstraint<F, GM, M, N, E> myConst = curConstraint;

			// Remove old tree node
			myConst.removeFromParent();
			_theFrame.getInfoTreeUI().addConstraint(myConst);

			// Referesh Tree
			_theFrame.getInfoTreeUI().refreshTree(myConst);
			_theFrame.getMModel().setDirty();
			_theFrame.getMModel().setSynced(false);
		} else {
			JOptionPane.showMessageDialog(_theFrame,
					"Revoming this path would make the constraint invalid.\nPath was not removed",
					"Path Not Removed", JOptionPane.ERROR_MESSAGE);
		}
	}

	// Selection is not a constraint
	else {
		JOptionPane.showMessageDialog(_theFrame,
				"You don't have a path selected. \nPlease select a path and try again.",
				"No ModelConstraint Selected", JOptionPane.ERROR_MESSAGE);
	}
}