Freiraum zwischen Knoten im JTree

[mightymop]

Hallöchen leute hab n kleines Problem mit dem JTree

also der JTree mal hier aus mir unerklärlichen Grünen ab der 2 Ebene immer ne riesen Lücke zwischen die Knoten
und dadurch lässt sich das darunter liegende Node nicht bzw nur schwer selektieren, eben dann wenn man auf den Leerraum klickt.

Ich habe einen CellRenderer von DefaultCellRenderer abgeleitet aber mache eigentlich nix außer die Schriftfarbe zu ändern. Ich habs auch mal mit dem DefaultCellRenderer versucht, selbes Problem.
siehe Bild...

Wenns irgendwelche Tips gäbe um das zu beseitigen wäre ich dankbar

ps: und ja ich hab mir das Tutorial durchgelesen und gegooglet usw...

cu mightymop

 

[Beni]

Das Bild führt nur zu einer 404... nix zu sehen.

 

[mightymop]

ups linkfehler im bild

so

mfg mightymop

 

[Beni]

Hat z.b. kat21 mehrmals aaaa oder bbbb als Kind? Falls ja: das kann den JTree verwirren: ein Knoten darf ein Kind nur einmal besitzen.

Falls nicht: Code ist immer nützlich :wink:

 

[Guest]

Hat z.b. kat21 mehrmals aaaa oder bbbb als Kind?

nope alles nur einmal...

ich mach das ja so dass ich ne baumstruktur mittels rekursiver funktion in den baum eintragen lasse

Class Baum:

package Windows.Tree;

import java.awt.*;
import java.awt.event.*;

import javax.swing.*;

import Windows.*;
import javax.swing.tree.DefaultTreeCellRenderer;


public class Baum extends mainpanel
{
    public JScrollPane scrollBaum = null;
    public MyTree baumTree = null;

    public static Baum Create(Datenverwaltung.BaumXML.baumobj Root,
                              resizedlg parent, String Text)
    {
        InfiniteModel mod = new InfiniteModel();
        mod.setRoot(createTree(Root, null));
        MyTree tree = new MyTree(mod);
    
        tree.setCellRenderer(new ColorRenderer());
        tree.setRootVisible(false);
        Baum baumTree = new Baum(new JScrollPane(tree), tree, parent, Text);

        return baumTree;
    }


    public Baum(JScrollPane scrollBaum, MyTree baumTree, resizedlg parent,
                String Text)
    {
        super(parent, Text);
        this.scrollBaum = scrollBaum;

        this.baumTree = baumTree;
        this.baumTree.addMouseListener(new Baum.MouseClick(baumTree));
        
        this.SetComponent(this.scrollBaum, 0, 0, 0, 0, 100, 100,
                          GridBagConstraints.BOTH, new Insets(18, 8, 8, 8));
    }

    public void Refresh(Datenverwaltung.BaumXML.baumobj Root)
    {

        Node root = (Node)this.baumTree.getModel().getRoot();
        root = createTree(Root, null);
        ((InfiniteModel)this.baumTree.getModel()).setRoot(root);

        this.baumTree.setAllowPaint(false);
        this.baumTree.updateUI();
        this.baumTree.setAllowPaint(true);
    }

    public void SetFontSize(int size)
    {
        super.SetFontSize(size);

        this.baumTree.setFont(new java.awt.Font("Arial", 1, size));

    }


    public class MouseClick extends MouseAdapter
    {
        private MyTree m_tree;

        public MouseClick(MyTree tree)
        {
            this.m_tree = tree;
        }

        public void mouseClicked(MouseEvent e)
        {

            if (this.m_tree.getRowForLocation(e.getX(), e.getY()) == -1)
            {
                this.m_tree.clearSelection();
            }

        }
    }


    private static Windows.Tree.Node createTree(Datenverwaltung.BaumXML.
                                                baumobj Item,
                                                Windows.Tree.Node parent)
    {

        if (Item == null)
        {
            return null;
        }

        Windows.Tree.Node aktElement = null;

        boolean isRoot = false;

        if (parent == null)
        {
            parent = new Windows.Tree.Node("Root", "1");
            isRoot = true;
            Baum.createTree(Item.child, parent);
        }

        if (isRoot)
        {
            return parent;
        }
                
        while (Item != null)
        {
            if (Item != null)
            {
                aktElement = new Windows.Tree.Node(Item.ref_Obj.GetBez(),
                        Item.ref_Obj.GetIDstr());
                parent.add(aktElement);

                if (Item.child != null)
                {
                    aktElement.add(Baum.createTree(Item.child, aktElement));
                }
                else
                {
                    aktElement.SetForegroundColor(Color.BLACK);
                    aktElement.SetBackgroundColor(Color.WHITE);//Color.decode("#e3f0f9"));
                }

                Item = Item.next;
            }
        }

        return aktElement;
    }


}

class MyTree

package Windows.Tree;

import java.awt.*;

import javax.swing.*;
import javax.swing.tree.*;

public class MyTree extends JTree
{
    boolean ballowpaint = true;

    public void setAllowPaint(boolean allow)
    {
        this.ballowpaint = allow;
    }

    public boolean getAllow()
    {
        return this.ballowpaint;
    }

    public MyTree(TreeModel mod)
    {
        super(mod);
    }


    public void paint(Graphics g)
    {
        if (this.ballowpaint)
        {
            super.paint(g);

        }
    }
}

Class ColorRenderer

package Windows.Tree;

import javax.swing.tree.DefaultTreeCellRenderer;
import java.awt.Component;
import javax.swing.*;
import javax.swing.tree.DefaultMutableTreeNode;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Insets;
import javax.swing.tree.TreeCellRenderer;

class ColorRenderer extends DefaultTreeCellRenderer
{
    public ColorRenderer()
    {
        // Versichern, dass der Hintergrund gezeichnet wird
        setOpaque(true);
    }

    public Component getTreeCellRendererComponent(
            JTree tree, Object value, boolean sel, boolean expanded,
            boolean leaf, int row, boolean hasFocus)
    {
        super.getTreeCellRendererComponent(tree, value, sel, expanded, leaf,
                                           row, hasFocus);

        // Den Wert des Knotens abfragen
        Node node = (Node) value;

        if (node.GetBackgroundColor() != null && node.GetForegroundColor() != null)
        {
            setBackground(node.GetBackgroundColor());
            setForeground(node.GetForegroundColor());
        }
        else
        {
            setBackground(tree.getBackground());
            setForeground(tree.getForeground());
        }

        if (sel)
        {
            setBackground(Color.decode("#e3f9e5"));
            setBorder(BorderFactory.createLineBorder(Color.decode("#63d398")));
        }
        else
        {
            setBorder(BorderFactory.createLineBorder(Color.WHITE));
        }

        return this;
    }
}

dass sind so die wichtigen klassen...

die Klasse Node ist von TreeNode abgeleitet und hatt lediglich noch mehr Attribute wie Farben, Daten usw..

wenn noch was gebraucht wird dann könnte ich das posten

 

[mightymop]

also am ColorCellRenderer und am MouseAdapter (MouseClick) liegts nich die hab ich schon mal weggelassen
Die Methode Refresh (Klasse Baum) verhält sich genauso wie die Create Methode....
Also kann der Fehler nur vorher kommen? Oder muss ich manuel noch irgendwo die Offsets der Knoten berechnen?

 

[Beni]

Ich sehe den Fehler nicht, ab der Baum sollte das automatisch berechnen.
Hängst du vielleicht irgendwo wieder Knoten ab ohne den JTree zu unterrichten?

Btw, updateUI macht nur Sinn wenn du das LookAndFeel änderst. Setz ein neues TreeModel (oder benutz die Listener) wenn du was änderst an den Daten :wink.

 

[mightymop]

ah glaub hab den fehler gefunden...

mein Cellrenderer war von DefaulTreeCellrenderer abgeleitet aber die Nodes direkt von TreeNode das hat dem nich so gefallen...
Also muss ich jetzt nen CellRenderer schreiben der von TreeCellrenderer abgeleitet ist

naja dann mach ich dass ma wie in den FAQ

thx for help

mfg migthtymop

 

[mightymop]

hm.. komisch wenn ich meine Nodes als DefaultMutableTreeNode nutze dann gehts mit dem CellRenderer der von DefaultCellRenderer abgeleitet ist...

wenn ich jetzt aber meine neuen Nodes von TreeNode ableite und nen eigenen Renderer schreibe sind da wieder diese Lücken ?!??

 

[mightymop]

mir is aufgefallen dass das problem nur bei den jeweils 2. Kindern auftritt
siehe bild

 

[Guest]

hier mal der neue CellRenderer und meine NodeKlasse sowie das TreeModel

Renderer:

package Windows.Tree;

import java.awt.*;

import javax.swing.*;
import javax.swing.tree.*;

public class ColorRenderer implements TreeCellRenderer
{

    private JPanel panel;
    private JButton icon;
    private JLabel label;

    public ColorRenderer()
    {

        panel = new JPanel(new GridBagLayout());
        icon = new JButton();
        label = new JLabel();

        label.setOpaque(true);
        panel.setBorder(null);

        panel.add(icon, new GridBagConstraints(0, 0, 1, 1, 1.0, 1.0,
                                               GridBagConstraints.WEST,
                                               GridBagConstraints.VERTICAL,
                                               new Insets(0, 0, 0, 0), 0, 0));
        panel.add(label, new GridBagConstraints(1, 0, 1, 1, 1.0, 1.0,
                                                GridBagConstraints.WEST,
                                                GridBagConstraints.BOTH,
                                                new Insets(0, 0, 0, 0), 0, 0));
    }

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

        Node node = (Node) value;

        if (node.GetBackgroundColor() != null && node.GetForegroundColor() != null)
        {
            this.label.setBackground(node.GetBackgroundColor());
            this.label.setForeground(node.GetForegroundColor());
        }
        else
        {
            this.label.setBackground(tree.getBackground());
            this.label.setForeground(tree.getForeground());
        }

        if (selected)
        {
            this.label.setBackground(Color.decode("#e3f9e5"));
            this.label.setBorder(BorderFactory.createLineBorder(Color.decode(
                    "#63d398")));
        }
        else
        {
            this.label.setBorder(BorderFactory.createLineBorder(Color.WHITE));
        }

        label.setText(value.toString());

        return panel;
    }

}

Nodes:

package Windows.Tree;

import java.awt.*;
import java.util.*;

import javax.swing.tree.*;

// Der unendliche Baum wird durch diese Node-Objekte dargestellt. Bei
// Bedarf kann sich so ein Nodeobjekt selbstständig neue Kinder erschaffen.
public class Node implements TreeNode
{
    private String name = "ITEM";
    private java.util.Vector children = null;
    private TreeNode m_parent = null;
    private boolean bAllowChildren = true;
    private Object m_Data = "DATA";
    private Color m_BackColor = null;
    private Color m_ForeColor = null;
    private Object m_Image = null;

    public Node(String name)
    {
        this.init(name, true, null, null);
    }

    public Node(String name, Object Data)
    {
        this.init(name, true, null, Data);
    }

    public Node(String name, boolean allowChildren)
    {
        this.init(name, allowChildren, null, null);
    }

    public Node(String name, TreeNode parent)
    {
        this.init(name, true, parent, null);
    }

    public Node(String name, boolean allowChildren, TreeNode parent)
    {
        this.init(name, allowChildren, parent, null);
    }

    public Node(String name, Object Data, boolean allowChildren, TreeNode parent)
    {
        this.init(name, allowChildren, parent, Data);
    }

    private void init(String name, boolean allowChildren, TreeNode parent,
                      Object Data)
    {
        this.children = new java.util.Vector();
        this.name = name;
        this.bAllowChildren = allowChildren;
        this.m_parent = parent;
        this.m_Data = Data;
    }

    public void SetData(Object Data)
    {
        this.m_Data = Data;
    }

    public Object GetData()
    {
        return this.m_Data;
    }

    public void SetImage(Object Data)
    {
        this.m_Image = Data;
    }

    public Object GetImage()
    {
        return this.m_Image;
    }

    public void SetForegroundColor(Color Data)
    {
        this.m_ForeColor = Data;
    }

    public Color GetForegroundColor()
    {
        return this.m_ForeColor;
    }

    public void SetBackgroundColor(Color Data)
    {
        this.m_BackColor = Data;
    }

    public Color GetBackgroundColor()
    {
        return this.m_BackColor;
    }

    public void del(int index)
    {
        if (index < children.size())
        {
            this.children.remove(index);
        }
    }

    private int getCcount()
    {
        return this.children.size();
    }

    private TreeNode getCAt(int index)
    {
        if (index < this.children.size())
        {
            return (TreeNode)this.children.get(index);
        }
        else
        {
            return null;
        }
    }

    public void setParent(TreeNode obj)
    {
        this.m_parent = obj;
    }

    public boolean add(TreeNode obj)
    {
        if (this.bAllowChildren)
        {
            ((Node) obj).setParent(this);
            this.children.add(obj);
            return true;
        }
        else
        {
            return false;
        }
    }

    public boolean insert(TreeNode obj, int index)
    {
        if (this.bAllowChildren)
        {
            return false;
        }
        else
        if (index < this.children.size())
        {
             ((Node) obj).setParent(this);
            this.children.insertElementAt(obj, index);
            return true;
        }
        else
        {
             ((Node) obj).setParent(this);
            this.children.add(obj);
            return true;
        }
    }

    public String toString()
    {
        return name;
    }

    public TreeNode getChildAt(int _int)
    {
        return (TreeNode)this.getCAt(_int);
    }

    public int getChildCount()
    {
        return this.getCcount();
    }

    public TreeNode getParent()
    {
        return (TreeNode)this.m_parent;
    }

    public int getIndex(TreeNode treeNode)
    {
        for (int n = 0; n < this.children.size(); n++)
        {
            if (this.getCAt(n).equals(treeNode))
            {
                return n;
            }
        }

        return 0;
    }

    public boolean getAllowsChildren()
    {
        return this.bAllowChildren;
    }

    public boolean isLeaf()
    {
       return this.children.size() == 0;
    }

    public Enumeration children()
    {
        return this.children.elements();
    }


}

Model:

package Windows.Tree;

import javax.swing.event.*;
import javax.swing.tree.*;

public class InfiniteModel implements TreeModel
{
    private java.util.Vector listeners = new java.util.Vector();

    public void addTreeModelListener(TreeModelListener listener)
    {
        listeners.add(listener);
    }

    public void removeTreeModelListener(TreeModelListener listener)
    {
        listeners.remove(listener);
    }

    public void add(TreePath parent, Node child)
    {
        // Den Knoten einbauen
        int index = getChildCount(parent.getLastPathComponent());
        ((Node) parent.getLastPathComponent()).insert(child, index);

        // Die Listener unterrichten
        TreeModelEvent event = new TreeModelEvent(
                this, // Quelle des Events
                parent, // Pfad zum Vater des veränderten Knoten
                new int[]
                {index}, // Index des veränderten Knotens
                new Object[]
                {child}); // Der neue Knoten

        for (int n = 0; n < this.listeners.size(); n++)
        {
            ((TreeModelListener) listeners.get(n)).treeNodesInserted(event);
        }
    }

    public void remove(TreePath path)
    {
        // Den Knoten entfernen
        Object parent = path.getParentPath().getLastPathComponent();
        Object child = path.getLastPathComponent();

        int index = getIndexOfChild(parent, child);
        ((Node) parent).del(index);

        // Die Listener unterrichten
        TreeModelEvent event = new TreeModelEvent(
                this, // Quelle des Events
                path.getParentPath(), // Pfad zum Vater des entfernten Knotens
                new int[]
                {index}, // Ehemaliger Index des Knotens
                new Object[]
                {child}); // Der entfernte Knoten

        for (int n = 0; n < this.listeners.size(); n++)
        {
            ((TreeModelListener) listeners.get(n)).treeNodesRemoved(event);
        }
    }

    private Object root = new Node("")
    {
        public String toString()
        {
            return "Root";
        }
    };


    public Object getRoot()
    {
        return root;
    }

    public void setRoot(Object root)
    {
        this.root = root;
    }

    public Object getChild(Object parent, int index)
    {
        TreeNode node = (TreeNode) parent;
        return node.getChildAt(index);
    }

    public int getChildCount(Object node)
    {
        TreeNode tmp = (TreeNode) node;
        if (tmp != null)
        {
            return tmp.getChildCount();
        }
        else
        {
            return -1;
        }
    }




    public boolean isLeaf(Object node)
    {

        return getChildCount(node) == 0;        
    }

    public int getIndexOfChild(Object parent, Object child)
    {
        TreeNode tmp = (TreeNode) parent;

        if (tmp == null)
        {
            return -1;
        }

        for (int i = 0; i < tmp.getChildCount(); i++)
        {
            if (tmp.getChildAt(i).equals(child))
            {
                return i;
            }
        }

        return -1;
    }

    public void valueForPathChanged(TreePath path, Object newValue)
    {
        // nicht beachten
    }
}

vielleicht kann wer ma testen...

mfg mightymop

 

[Guest]

*hochschieb*

hat denn keiner ne andere lösung als die paint methode zu überschreiben?

 

[mightymop]

so habs geschafft... ;P

 

[Beni]

Aus reiner Neugier: wie hast du das hingekriegt, und was war falsch?

 

[mightymop]

ich hab meine node klasse nochma angeguckt und man muss da höllisch auffpassen die reichtigen variablen anzusprechen also mann muss als String der im baum erscheint die variablen der super klasse benutzten (DefaultMutableTreeNode) und deren funktionen zum befüllen und usw... ich hatte da vorher neue variablen genommen...
das problem war wohl dass er einmal versucht hat objekte der superklasse in den baum einzutragen deren inhalt ja dann leer sein musste und die objekte meiner klasse.. komisch nur dass das problem dann immer nur beim 2 kind usw. auftrat... naja so in etwa wars.... hab halt alle methoden nochmals angeguckt und immer die variablen der super klassen angesprochen und nur zusätzliche neue variablen mit neuen funktionen bedient....

cu mightymop