Re: Event Listening Components in JTree Nodes

ok, I tried it, stepped all the event dispatching code, and during
stepping it worked (sometimes?), but not while running it normal...
I assembeld an own example on top of:
http://www.java2s.com/Code/Java/Swing-JFC/CheckBoxNodeTreeSample.htm

Here I have added beside the checkbox an Jbutton to every leafnode.
The checkbox is reacting on the first click, but the button works only
correct, after the node is selected. It seems like there is a reason
why the button dont like to consume the click event, even it is
dispatched to him... but during single step mode this behavior seems
to change, so I guess Im not able to find a solution this way...

Could Someone help me? I tryed this now for at least 2 days.... :-(

THX!!!!!!!!!
Marco

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

import javax.swing.AbstractCellEditor;
import javax.swing.BoxLayout;
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.TreeCellEditor;
import javax.swing.tree.TreeCellRenderer;
import javax.swing.tree.TreePath;

public class CheckBoxNodeTreeSample {
  @SuppressWarnings("unchecked")
public static void main(String args[]) {
    JFrame frame = new JFrame("CheckBox Tree");
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

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

    JScrollPane scrollPane = new JScrollPane(tree);
    frame.getContentPane().add(scrollPane, BorderLayout.CENTER);
    frame.setSize(300, 150);
    frame.setVisible(true);
  }
}

class CheckBoxNodeRenderer implements TreeCellRenderer {

  private JPanel leafRenderer = new JPanel();
  public JCheckBox checkBox = new JCheckBox();
  public JButton btnTest= new JButton("test");
  private DefaultTreeCellRenderer nonLeafRenderer = new
DefaultTreeCellRenderer();

  Color selectionBorderColor, selectionForeground,
selectionBackground,textForeground, textBackground;

  public CheckBoxNodeRenderer() {
    Font fontValue;
    fontValue = UIManager.getFont("Tree.font");
    if (fontValue != null) {
     checkBox.setFont(fontValue);
    }

    btnTest.addMouseListener(new MouseListener(){
        public void mouseClicked(MouseEvent e) {
            System.out.println(System.currentTimeMillis() + e.toString());
        }
        public void mouseEntered(MouseEvent e) {
            System.out.println(System.currentTimeMillis() + e.toString());
        }
        public void mouseExited(MouseEvent e) {
            System.out.println(System.currentTimeMillis() + e.toString());
        }
        public void mousePressed(MouseEvent e) {
            System.out.println(System.currentTimeMillis() + e.toString());
        }
        public void mouseReleased(MouseEvent e) {
            System.out.println(System.currentTimeMillis() + e.toString());
        }

    });

    leafRenderer.setLayout(new BoxLayout
(leafRenderer,BoxLayout.X_AXIS));
    leafRenderer.add(checkBox);
    leafRenderer.add(btnTest);

    Boolean booleanValue = (Boolean) UIManager.get
("Tree.drawsFocusBorderAroundIcon");
    checkBox.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);
      checkBox.setText(stringValue);
      checkBox.setSelected(false);

      checkBox.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;
            checkBox.setText(node.getText());
            checkBox.setSelected(node.isSelected());

          }
        }
        returnValue = leafRenderer;
      } else {
        returnValue = nonLeafRenderer.getTreeCellRendererComponent
(tree,
            value, selected, expanded, leaf, row, hasFocus);
      }
      return returnValue;
    }
}

class CheckBoxNodeEditor extends AbstractCellEditor implements
TreeCellEditor {

  /**
     *
     */
    private static final long serialVersionUID = -4970953040907178677L;

CheckBoxNodeRenderer renderer = new CheckBoxNodeRenderer();

  ChangeEvent changeEvent = null;

  JTree tree;

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

  public Object getCellEditorValue() {
    JCheckBox checkbox = renderer.checkBox;
    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 JPanel) {
        renderer.checkBox.addItemListener(itemListener);
    }
    renderer.btnTest.setRequestFocusEnabled(true);

    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 + "]";
  }
}

@SuppressWarnings("unchecked")
class NamedVector extends Vector {
  /**
     *
     */
    private static final long serialVersionUID = 7268564620735582077L;
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 + "]";
  }
}

On 30 Apr., 14:49, Michael Rauscher <michlm...@gmx.de> wrote: