Grafische Ausgabe eines 2 dimensionales Array gesucht

[lokly]

Hi Leute,

ich habe folgendes Problem:
Habe eine Liste mit LAN/WAN IPs Adressen, diese sind einem Netzwerk zugeordnet und ein * kennzeichnet dabei, ob das Netzwerk aktiv ist oder nicht.

Hier mal Beispiel:

* [Netzwerkname]
10.0.0.1
* 12.0.0.1           192.168.1.1
10.0.0.2

Speichern tue ich es in einem [ i ][ 3 ] String Array wobei nicht aktivierte IPs bzw. Netzwerke mit "null" gekennzeichnet werden. Das läuft auch ganz gut.

Jetzt wollte ich eine nette grafische Swing Oberfläche drauf packen, bin aber nicht so der Held was Grafik und Design angeht

Ich dachte zuerst an einen JTree, wobei ein Knoten dann der Netzwerkname ist und ein Blatt die IP Adresse. Wollte dabei aber auch gerne einen grünen Punkt für eine aktive Verbindung setzen und einen roten für eine Offline Adresse (wenn das mit JTree überhaupt geht).
Dachte auch schon an eine Tabelle, die das Darstellen soll, aber die hat ja leider nicht die "Einklappfunktion" (soweit ich weiß).

Was für eine Komponente würdet ihr mir für mein vorhaben empfehlen? JTree oder vielleicht doch einen JTable oder etwas ganz anderes?

Bin für jeden Vorschlag offen muss auch nicht Swing sein.

Und falls es noch wichtig ist: Die Liste wird sich alle 2 Sek. Updaten und somit auch die Komponente.

 

[Ryu20]

hmm wo sind die alten Posts?

naja hier eine Lösung:

NetworkTree.java

import java.awt.Component;
import java.util.StringTokenizer;

import javax.swing.Icon;
import javax.swing.ImageIcon;
import javax.swing.JTree;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeCellRenderer;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.TreePath;

public class NetworkTree extends JTree{

    private static final long serialVersionUID = 9196682220315814245L;
    private String[][] list;
    private DefaultMutableTreeNode root;
    private DefaultMutableTreeNode parent;
    private DefaultMutableTreeNode child;
    private DefaultTreeModel dtm;

    public String[][] getList() {
        return list;
    }

    public void setList(String[][] list) {
        this.list = list;
    }

    public NetworkTree(String[][] list){
        this.list = list;
        this.setCellRenderer(new networkTreeRenderer());
        createTree();

        //Alle 2 Sekunden update
        new Thread(){
            @Override
            public void run() {
                while(true){
                    try {
                        Thread.sleep(2000);
                        String backup = getExpansionState(NetworkTree.this, 0);
                        createTree();
                        restoreExpanstionState(NetworkTree.this, 0, backup);
                    } catch (InterruptedException e) {

                    }
                }
            }

        }.start();
    }

    private void createTree(){

        boolean active = false;
        root  = new DefaultMutableTreeNode("Netzwerk");
        for (int i = 0; i< list.length; i++){
            String[] tmp = list[i];
            System.out.println(tmp[0]);
            if (tmp[0].equals("*")){
                active = true;
            } else {
                active = false;
            }

            if (tmp[1].startsWith("[")){
                String parentStr = tmp[1];
                parentStr = parentStr.replaceAll("\\[", "");
                parentStr = parentStr.replaceAll("\\]", "");
                parent = new DefaultMutableTreeNode(parentStr);
                root.add(parent);
            }else {
                String childStr;
                if (active){
                    childStr = tmp[3];

                }else {
                    childStr = tmp[1];
                }
                child = new DefaultMutableTreeNode(new IPClass(childStr, active));
                parent.add(child);
            }

        }

        dtm = new DefaultTreeModel(root);
        this.setModel(dtm);
    }

    class IPClass{
        private String ip;
        private boolean active;
        public IPClass(String ip, boolean active){
            this.ip = ip;
            this.active = active;
        }

        public String getIp() {
            return ip;
        }

        public void setIp(String ip) {
            this.ip = ip;
        }

        public boolean isActive() {
            return active;
        }

        public void setActive(boolean active) {
            this.active = active;
        }

        @Override
        public String toString() {
            //Wichtig damit dies angezeigt wird
            return ip;
        }


    }

    class networkTreeRenderer extends DefaultTreeCellRenderer{

        private static final long serialVersionUID = 1898197542861483637L;
        Icon red = new ImageIcon("C:\\red.gif");
        Icon green = new ImageIcon("C:\\green.gif");

        @Override
        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);
            DefaultMutableTreeNode node = (DefaultMutableTreeNode) value;
            if (node.getUserObject() instanceof IPClass){
                IPClass tmpIP = (IPClass) node.getUserObject();
                if (tmpIP.isActive()){
                    setIcon(green);
                }else {
                    setIcon(red);
                }
            }
            return this;
        }
    }

    
    //Ab hier hab ich nichts selbst gemacht, hab ich mal im Internet gefunden.
    public static boolean isDescendant(TreePath path1, TreePath path2){
        int count1 = path1.getPathCount();
        int count2 = path2.getPathCount();
        if(count1<=count2)
            return false;
        while(count1!=count2){
            path1 = path1.getParentPath();
            count1--;
        }
        return path1.equals(path2);
    }

    public static String getExpansionState(JTree tree, int row){
        TreePath rowPath = tree.getPathForRow(row);
        StringBuffer buf = new StringBuffer();
        int rowCount = tree.getRowCount();
        for(int i=row; i<rowCount; i++){
            TreePath path = tree.getPathForRow(i);
            if(i==row || isDescendant(path, rowPath)){
                if(tree.isExpanded(path))
                    buf.append(","+String.valueOf(i-row));
            }else
                break;
        }
        return buf.toString();
    }

    public static void restoreExpanstionState(JTree tree, int row, String expansionState){
        StringTokenizer stok = new StringTokenizer(expansionState, ",");
        while(stok.hasMoreTokens()){
            int token = row + Integer.parseInt(stok.nextToken());
            tree.expandRow(token);
        }
    }

}

Deine Klassse: (leicht geändert)

import java.awt.BorderLayout;
import java.util.Scanner;

import javax.swing.JFrame;

public class JTreeNetworkSample {
    
        /**
         * 
         * @param list String der in das Array eingelesen werden soll
         * @return     String [zeilenDesStringList][4]
         *             [0] 
         *                 * wenn das Netzwerk aktiv ist, null wenn es nicht aktiv ist
         *             [1] 
         *                 ist entweder die interne IP - fängt immer mit 10. an 
         *                 oder der Netzwerkname - steht immer in einem Block [Netzwerkname]
         *                 Dieser Wert ist niemals "null"
         *             [2]
         *                 wenn [0] ein * enthält (aktiv ist), und [1] kein Netzwerk ist, 
         *                 also eine IP die mit 10. anfängt, steht hier in [2] der Username 
         *             [3]
         *                 wenn [0] ein * enthält (aktiv ist), und [1] kein Netzwerk ist,
         *                 also eine IP die mit 10. anfängt, steht hier in [3] die Externe IP 
         */
        public static String[][]listBuilder(String list){
            
            int allLines=0;
            Scanner tmp = new Scanner(list);
            while(tmp.hasNextLine()){
                allLines++;
                tmp.nextLine();
            }
            
            String [][]a=new String[allLines][4];
            
            Scanner s = new Scanner(list);
            
            int y=0;
            while(s.hasNextLine()){
                Scanner c = new Scanner(s.nextLine());
                int z=0;
                while(c.hasNext()){
                    a[y][z]=c.next();
                    z++;
                }
                y++;
            }
            for(int i=0;i<a.length;i++){
                if(!a[i][0].equals("*")){
                    a[i][1]=a[i][0];
                    a[i][0]="null";
                }
            }
            return a;
        }

        public static void main(String[] args) {
            String [][] a = listBuilder(" * [NetzwerknameEins]\n"+
            "       10.31.151.210\n"+            
            "     * 10.31.151.207     UserZwei                80.43.5.2:1046\n"+
            " * [NetzwerknameZwei]\n"+
            "     * 10.31.151.213     UserVier                87.144.133.56:1046\n"+
            "       10.31.151.211\n"+            
            " [NetzwerknameDrei]\n"+
            "       10.31.151.13\n"+                
            "       10.31.151.121\n");
            
            JFrame fr = new JFrame();
            fr.setLayout(new BorderLayout());
            fr.add(new NetworkTree(a), BorderLayout.CENTER);
            fr.setSize(800, 600);
            fr.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            fr.setVisible(true);
        }
        
        public static void print(String [][]a){
            for(int i=0;i<a.length;i++){
                for(int j=0;j<4;j++){
                    System.out.print(a[i][j]);
                }
                System.out.println();
            }
        }
}

Also alle 2 Sekunden lädt er den Tree komplett neu.
Würd ich an deiner Stelle noch anpassen da das nicht wirklich sauber ist.
Außerdem gibt es beim komplettem neu laden Probleme wenn du was selektieren willst.

Hier hab ich mal gepostet wie ein kleines Update geht:

http://www.tutorials.de/forum/rich-client-entwicklung-java-desktop/308734-jtree-updaten.html

im Anhang findest du die benötigten Bilder (kannst ja auch noch selbst welche machen)

Ich hoffe das reicht als kleines Beispiel ;-)

 

[lokly]

Das war echt super nett von dir, vielen Dank dafür!