[Java] Tree Checkbox auslesen

Dieses Thema im Forum "Programmierung & Entwicklung" wurde erstellt von tobi, 5. Juli 2011 .

  1. Diese Seite verwendet Cookies. Wenn du dich weiterhin auf dieser Seite aufhältst, akzeptierst du unseren Einsatz von Cookies. Weitere Informationen
  1. #1 5. Juli 2011
    Tree Checkbox auslesen

    Hallo Leute,

    ich habe mir mal ein kleinen Script Schnippsel zusammen gebastelt...
    Es erstellt einen Baum mit Checkboxen auf den untersten Ebenen.
    Nun würde ich gern wissen, wie ich diese Checkboxen auslesen kann :(

    Am liebsten wäre mir je Knoten ein String Array, welches die Bezeichnungen der aktivierten Boxen liefert.

    Kann mir da vll jemand helfen? Unten ist der Code...

    Wäre echt super ;(

    danke schonmal..
    MfG



    Code:
    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.util.EventObject;
    import java.util.Vector;
    
    import javax.swing.AbstractCellEditor;
    import javax.swing.JCheckBox;
    import javax.swing.JFrame;
    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.DefaultTreeCellEditor;
    import javax.swing.tree.DefaultTreeCellRenderer;
    import javax.swing.tree.TreeCellEditor;
    import javax.swing.tree.TreeCellRenderer;
    import javax.swing.tree.TreeNode;
    import javax.swing.tree.TreePath;
    
    class TreeNodeVector<E> extends Vector<E> {
     String name;
    
     TreeNodeVector(String name) {
     this.name = name;
     }
    
     TreeNodeVector(String name, E elements[]) {
     this.name = name;
     for (int i = 0, n = elements.length; i < n; i++) {
     add(elements[i]);
     }
     }
    
     public String toString() {
     return "[" + name + "]";
     }
    }
    
    class LeafCellEditor extends DefaultTreeCellEditor {
    
     public LeafCellEditor(JTree tree, DefaultTreeCellRenderer renderer, TreeCellEditor editor) {
     super(tree, renderer, editor);
     }
    
     public boolean isCellEditable(EventObject event) {
     boolean returnValue = super.isCellEditable(event);
     if (returnValue) {
     Object node = tree.getLastSelectedPathComponent();
     if ((node != null) && (node instanceof TreeNode)) {
     TreeNode treeNode = (TreeNode) node;
     returnValue = treeNode.isLeaf();
     }
     }
     return returnValue;
     }
    }
    
    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 CheckBoxNodeRenderer implements TreeCellRenderer {
     private JCheckBox leafRenderer = new JCheckBox();
    
     private DefaultTreeCellRenderer nonLeafRenderer = new DefaultTreeCellRenderer();
    
     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()));
     }
    
     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 ((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);
    
     ItemListener itemListener = new ItemListener() {
     public void itemStateChanged(ItemEvent itemEvent) {
     if (stopCellEditing()) {
     fireEditingStopped();
     }
     }
     };
     if (editor instanceof JCheckBox) {
     ((JCheckBox) editor).addItemListener(itemListener);
     }
     return editor;
     }
    }
    
    public class CheckBoxNodeTreeSample {
     public static void main(String args[]) {
     JFrame frame = new JFrame("CheckBox Tree");
     frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    
     CheckBoxNode Knoten1[] = { new CheckBoxNode("Hauptschule", false),
     new CheckBoxNode("Realschule", false), new CheckBoxNode("Abitur", false) };
     
     CheckBoxNode Knoten2[] = { new CheckBoxNode("Cisco Admin", false), new CheckBoxNode("Personalmanagement", false),
     new CheckBoxNode("FiBu", false)};
     
     CheckBoxNode Knoten3[] = { new CheckBoxNode("Führerschein", false), new CheckBoxNode("Office", false),
     new CheckBoxNode("SAP", false)};
     
     Vector<CheckBoxNode> accessVector = new TreeNodeVector<CheckBoxNode>("Schulbildung", Knoten1);
     Vector<CheckBoxNode> browseVector = new TreeNodeVector<CheckBoxNode>("Weiterbildung", Knoten2);
     Vector<CheckBoxNode> browseVector2 = new TreeNodeVector<CheckBoxNode>("Kenntnisse", Knoten3);
     Object rootNodes[] = { accessVector, browseVector, browseVector2 };
     Vector<Object> rootVector = new TreeNodeVector<Object>("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.add(scrollPane, BorderLayout.CENTER);
     frame.setSize(300, 150);
     frame.setVisible(true);
     }
    }
    
     

  2. Anzeige
    Dealz: stark reduzierte Angebote finden.

  3. Videos zum Thema
Die Seite wird geladen...
Similar Threads - Java Tree Checkbox
  1. Antworten:
    7
    Aufrufe:
    3.639
  2. Antworten:
    1
    Aufrufe:
    344
  3. Antworten:
    1
    Aufrufe:
    279
  4. Antworten:
    1
    Aufrufe:
    300
  5. [Java] Java-Tree

    Forn , 31. Januar 2007 , im Forum: Programmierung & Entwicklung
    Antworten:
    2
    Aufrufe:
    346