Java'；复选框节点树示例'；DefaultMutableNode不'；你没有听众吗？

我在向现有树添加新节点时遇到问题。我的树基于您可以在链接中看到的CheckBoxNodeTreeSample：

我只是尝试通过执行“标准”操作来添加一个新节点：

DefaultTreeModel model = (DefaultTreeModel) this.view.getResultTree().getModel();
        DefaultMutableTreeNode root = (DefaultMutableTreeNode) model.getRoot();
        DefaultMutableTreeNode newNode = new DefaultMutableTreeNode("newNode");
        root.add(newNode);
        model.reload(root);

这很好，添加了一个新节点，但与其他现有节点的区别在于我不能单击复选框，它不可单击。我试图打印新节点和现有节点的路径，如下所示：

newNode
Model.CheckBoxNode[Person,..../true]

我试图解决这个问题已经有一段时间了，但我不知道如何解决这个问题。。如果您能提供一些帮助，我们将不胜感激！：）

我应该尝试像这样添加向量吗？这可能就是标准溶液不起作用的原因吗？我一直在尝试，但模型不喜欢向量、对象或类似的东西。。铸造也不起作用。这是树的初始化，以及它们如何使用向量和checkboxnodes：

CheckBoxNode accessibilityOptions[] = {
    new CheckBoxNode(
        "Move system caret with focus/selection changes", false),
    new CheckBoxNode("Always expand alt text for images", true) };
CheckBoxNode browsingOptions[] = {
    new CheckBoxNode("Notify when downloads complete", true),
    new CheckBoxNode("Disable script debugging", true),
    new CheckBoxNode("Use AutoComplete", true),
    new CheckBoxNode("Browse in a new process", false) };
Vector accessVector = new NamedVector("Accessibility",
    accessibilityOptions);
Vector browseVector = new NamedVector("Browsing", browsingOptions);
Object rootNodes[] = { accessVector, browseVector };
Vector rootVector = new NamedVector("Root", rootNodes);
JTree tree = new JTree(rootVector);

CheckBoxNodeRenderer renderer = new CheckBoxNodeRenderer();
tree.setCellRenderer(renderer);

tree.setCellEditor(new CheckBoxNodeEditor(tree));
tree.setEditable(true);

---

如果您没有找到任何正确的答案，这里是一篇我询问并回答了如何构建复选框树的帖子：

---

它可能会帮助您

以防万一，如果您没有找到任何正确的答案，下面是我询问并回答了如何构建复选框树的帖子：

---

这可能对你有帮助

我做了一个SSCCE。有一个按钮可以单击添加新节点，带有复选框，但不可单击。我没有在任何地方创建jcheckbox，所以我真的不明白应该在哪里放置一个额外的侦听器，也不明白为什么它不在编辑器中使用getTreeCellEditorComponent（）

我还尝试了一种稍微不同的方法，使用model.insertNodeInto（），但仍然无法单击复选框。我相信我应该能够创建checkboxNode而不是DefaultMutableTreeNode，但JTree模型不希望这样，因此尝试将其转换为DefaultMutableTreeNode。。无论如何，谢谢你迄今为止的帮助

更新：因为新节点不是CheckBoxNode类型。因此侦听器不能在节点上工作。所以现在我正在寻找解决方案来创建一个CheckBoxNode[]，将其添加到一个向量，然后将其添加为一个节点（这是可能的！）。这就是作者制作JTree的方式，所以我想类似的东西可能就是答案

 import java.awt.BorderLayout;
    import java.awt.Color;
    import java.awt.Component;
    import java.awt.Font;
    import java.awt.event.ActionEvent;
    import java.awt.event.ActionListener;
    import java.awt.event.ItemEvent;
    import java.awt.event.ItemListener;
    import java.awt.event.MouseEvent;
    import java.util.EventObject;
    import java.util.Vector;

import javax.swing.AbstractCellEditor;
import javax.swing.JButton;
import javax.swing.JCheckBox;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTree;
import javax.swing.UIManager;
import javax.swing.event.ChangeEvent;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeCellRenderer;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.TreeCellEditor;
import javax.swing.tree.TreeCellRenderer;
import javax.swing.tree.TreePath;

    public class CheckBoxNodeTreeSample {

    private static JTree tree;

  public static void main(String args[]) {
    JFrame frame = new JFrame("CheckBox Tree");

    CheckBoxNode accessibilityOptions[] = {
        new CheckBoxNode(
            "Move system caret with focus/selection changes", false),
        new CheckBoxNode("Always expand alt text for images", true) };
    CheckBoxNode browsingOptions[] = {
        new CheckBoxNode("Notify when downloads complete", true),
        new CheckBoxNode("Disable script debugging", true),
        new CheckBoxNode("Use AutoComplete", true),
        new CheckBoxNode("Browse in a new process", false) };
    Vector accessVector = new NamedVector("Accessibility",
        accessibilityOptions);
    Vector browseVector = new NamedVector("Browsing", browsingOptions);
    Object rootNodes[] = { accessVector, browseVector };
    Vector rootVector = new NamedVector("Root", rootNodes);
    tree = new JTree(rootVector);

    CheckBoxNodeRenderer renderer = new CheckBoxNodeRenderer();
    tree.setCellRenderer(renderer);

    tree.setCellEditor(new CheckBoxNodeEditor(tree));
    tree.setEditable(true);

    JScrollPane scrollPane = new JScrollPane(tree);
    frame.getContentPane().add(scrollPane, BorderLayout.NORTH);

    JPanel buttonPanel = new JPanel();
    JButton button = new JButton("new node");
    buttonPanel.add(button);
    frame.getContentPane().add(buttonPanel, BorderLayout.SOUTH);
    button.addActionListener(new ActionListener() {

        @Override
        public void actionPerformed(ActionEvent arg0) {
            DefaultTreeModel model = (DefaultTreeModel) tree.getModel();
            DefaultMutableTreeNode root = (DefaultMutableTreeNode) model.getRoot();
            DefaultMutableTreeNode newNode = new DefaultMutableTreeNode("New node");
            root.add(newNode);
            model.reload();


        }
    });

    frame.setSize(300, 450);
    frame.setVisible(true);
  }
}

class CheckBoxNodeRenderer implements TreeCellRenderer {
  private JCheckBox leafRenderer = new JCheckBox();

  private DefaultTreeCellRenderer nonLeafRenderer = new DefaultTreeCellRenderer();

  Color selectionBorderColor, selectionForeground, selectionBackground,
      textForeground, textBackground;

  protected JCheckBox getLeafRenderer() {
    return leafRenderer;
  }

  public CheckBoxNodeRenderer() {
    Font fontValue;
    fontValue = UIManager.getFont("Tree.font");
    if (fontValue != null) {
      leafRenderer.setFont(fontValue);
    }
    Boolean booleanValue = (Boolean) UIManager
        .get("Tree.drawsFocusBorderAroundIcon");
    leafRenderer.setFocusPainted((booleanValue != null)
        && (booleanValue.booleanValue()));

    selectionBorderColor = UIManager.getColor("Tree.selectionBorderColor");
    selectionForeground = UIManager.getColor("Tree.selectionForeground");
    selectionBackground = UIManager.getColor("Tree.selectionBackground");
    textForeground = UIManager.getColor("Tree.textForeground");
    textBackground = UIManager.getColor("Tree.textBackground");
  }

  public Component getTreeCellRendererComponent(JTree tree, Object value,
      boolean selected, boolean expanded, boolean leaf, int row,
      boolean hasFocus) {

    Component returnValue;
    if (leaf) {

      String stringValue = tree.convertValueToText(value, selected,
          expanded, leaf, row, false);
      leafRenderer.setText(stringValue);
      leafRenderer.setSelected(false);

      leafRenderer.setEnabled(tree.isEnabled());

      if (selected) {
        leafRenderer.setForeground(selectionForeground);
        leafRenderer.setBackground(selectionBackground);
      } else {
        leafRenderer.setForeground(textForeground);
        leafRenderer.setBackground(textBackground);
      }

      if ((value != null) && (value instanceof DefaultMutableTreeNode)) {
        Object userObject = ((DefaultMutableTreeNode) value)
            .getUserObject();
        if (userObject instanceof CheckBoxNode) {
          CheckBoxNode node = (CheckBoxNode) userObject;
          leafRenderer.setText(node.getText());
          leafRenderer.setSelected(node.isSelected());
        }
      }
      returnValue = leafRenderer;
    } else {
      returnValue = nonLeafRenderer.getTreeCellRendererComponent(tree,
          value, selected, expanded, leaf, row, hasFocus);
    }
    return returnValue;
  }
}

class CheckBoxNodeEditor extends AbstractCellEditor implements TreeCellEditor {

  CheckBoxNodeRenderer renderer = new CheckBoxNodeRenderer();

  ChangeEvent changeEvent = null;

  JTree tree;

  public CheckBoxNodeEditor(JTree tree) {
    this.tree = tree;
  }

  public Object getCellEditorValue() {
    JCheckBox checkbox = renderer.getLeafRenderer();
    CheckBoxNode checkBoxNode = new CheckBoxNode(checkbox.getText(),
        checkbox.isSelected());
    return checkBoxNode;
  }

  public boolean isCellEditable(EventObject event) {
    boolean returnValue = false;
    if (event instanceof MouseEvent) {
      MouseEvent mouseEvent = (MouseEvent) event;
      TreePath path = tree.getPathForLocation(mouseEvent.getX(),
          mouseEvent.getY());
      if (path != null) {
        Object node = path.getLastPathComponent();
        if ((node != null) && (node instanceof DefaultMutableTreeNode)) {
          DefaultMutableTreeNode treeNode = (DefaultMutableTreeNode) node;
          Object userObject = treeNode.getUserObject();
          returnValue = ((treeNode.isLeaf()) && (userObject instanceof CheckBoxNode));
        }
      }
    }
    return returnValue;
  }

  public Component getTreeCellEditorComponent(JTree tree, Object value,
      boolean selected, boolean expanded, boolean leaf, int row) {

    Component editor = renderer.getTreeCellRendererComponent(tree, value,
        true, expanded, leaf, row, true);

    // editor always selected / focused
    ItemListener itemListener = new ItemListener() {
      public void itemStateChanged(ItemEvent itemEvent) {
        if (stopCellEditing()) {
          fireEditingStopped();
        }
      }
    };
    if (editor instanceof JCheckBox) {
      ((JCheckBox) editor).addItemListener(itemListener);
    }

    return editor;
  }
}

class CheckBoxNode {
  String text;

  boolean selected;

  public CheckBoxNode(String text, boolean selected) {
    this.text = text;
    this.selected = selected;
  }

  public boolean isSelected() {
    return selected;
  }

  public void setSelected(boolean newValue) {
    selected = newValue;
  }

  public String getText() {
    return text;
  }

  public void setText(String newValue) {
    text = newValue;
  }

  public String toString() {
    return getClass().getName() + "[" + text + "/" + selected + "]";
  }
}

class NamedVector extends Vector {
  String name;

  public NamedVector(String name) {
    this.name = name;
  }

  public NamedVector(String name, Object elements[]) {
    this.name = name;
    for (int i = 0, n = elements.length; i < n; i++) {
      add(elements[i]);
    }
  }

  public String toString() {
    return "[" + name + "]";
  }
}

导入java.awt.BorderLayout；
导入java.awt.Color；
导入java.awt.Component；
导入java.awt.Font；
导入java.awt.event.ActionEvent；
导入java.awt.event.ActionListener；
导入java.awt.event.ItemEvent；
导入java.awt.event.ItemListener；
导入java.awt.event.MouseEvent；
导入java.util.EventObject；
导入java.util.Vector；
导入javax.swing.AbstractCellEditor；
导入javax.swing.JButton；
导入javax.swing.JCheckBox；
导入javax.swing.JFrame；
导入javax.swing.JPanel；
导入javax.swing.JScrollPane；
导入javax.swing.JTree；
导入javax.swing.UIManager；
导入javax.swing.event.ChangeEvent；
导入javax.swing.tree.DefaultMutableTreeNode；
导入javax.swing.tree.DefaultTreeCellRenderer；
导入javax.swing.tree.DefaultTreeModel；
导入javax.swing.tree.TreeCellEditor；
导入javax.swing.tree.TreeCellRenderer；
导入javax.swing.tree.TreePath；
公共类CheckBoxNodeTreeSample{
私有静态JTree树；
公共静态void main（字符串参数[]）{
JFrame=newjframe（“复选框树”）；
CheckBoxNode访问选项[]={
新CheckBoxNode(
“使用焦点/选择更改移动系统插入符号”，错误），
新建CheckBoxNode（“始终展开图像的alt文本”，true）}；
CheckBoxNode浏览选项[]={
新建CheckBoxNode（“下载完成时通知”，true），
新建CheckBoxNode（“禁用脚本调试”，true），
新的CheckBoxNode（“使用自动完成”，true），
新建CheckBoxNode（“在新进程中浏览”，false）}；
Vector accessVector=新名称Vector（“可访问性”，
可访问性选项）；
Vector browseVector=新名称Vector（“浏览”，浏览选项）；
对象根节点[]={accessVector，browseVector}；
Vector rootVector=新名称Vector（“根”，rootNodes）；
树=新的JTree（根向量）；
CheckBoxNodeRenderer渲染器=新的CheckBoxNodeRenderer（）；
setCellRenderer（渲染器）；
setCellEditor（新的CheckBoxNodeEditor（树））；
tree.setEditable（true）；
JScrollPane scrollPane=新的JScrollPane（树）；
frame.getContentPane（）.add（滚动窗格，BorderLayout.NORTH）；
JPanel buttonPanel=新的JPanel（）；
JButton按钮=新JButton（“新节点”）；
按钮面板。添加（按钮）；
frame.getContentPane（）.add（buttonPanel，BorderLayout.SOUTH）；
addActionListener（新建ActionListener（））{
@凌驾
已执行的公共无效操作（操作事件arg0）{
DefaultTreeModel模型=（DefaultTreeModel）tree.getModel（）；
DefaultMutableTreeNode根=（DefaultMutableTreeNode）model.getRoot（）；
DefaultMutableTreeNode newNode=新的DefaultMutableTreeNode（“新节点”）；
添加（newNode）；
model.reload（）；
}
});
框架。设置尺寸（300450）；
frame.setVisible（true）；
}
}
类CheckBoxNodeRenderer实现TreeCellRenderer{
私有JCheckBox leaverenderer=新的JCheckBox（）；
私有DefaultTreeCellRenderer nonLeafRenderer=新的DefaultTreeCellRenderer（）；
颜色选择边框颜色，选择前景，选择背景，
文本前景，文本背景；
受保护的JCheckBox getLeafRenderer（）{
返回页面渲染器；
}
公共CheckBoxNodeRenderer（）{
字体字体值；
fontValue=UIManager.getFont（“Tree.font”）；
如果（fontValue！=null）{
setFont（fontValue）；
}
布尔布尔值=（布尔）UIManager
.get（“Tree.drawsFocusBorderAroundIcon”）；
leafRenderer.setFocusPaint（（booleanValue！=null）
&&（booleanValue.booleanValue（））；
selectionBorderColor=UIManager.getColor（“Tree.selectionBorderColor”）；
selection前台=UIManager.g