Toon posts:

[JAVA] Progressbar & Cellrendering

Pagina: 1
Acties:

Verwijderd

Topicstarter
Ik heb een probleempje met mijn cellrenderer, hij wil telkens de cell met de progressbar slechts updaten wanneer ik er op klik. Ik heb al geprobeerd met lussen alle cellen te doorlopen maar tevergeefs.

Hier had ik al eens gegeken voor informatie over cellrendering maar ik begrijp het eerlijk gezegd niet perfect:
http://www-128.ibm.com/developerworks/java/library/j-jtable/

code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
import java.awt.*;
import javax.swing.*;
import java.io.*;
import java.net.*;
import java.util.ArrayList;
import java.util.Collection;
import javax.swing.table.DefaultTableModel;
import javax.swing.table.TableCellRenderer;

//Aan de kant van de downloader
public class download {
    
    
    public void getFile(Object ipAddy, Object fileGet, Object size,DefaultTableModel model,JTable tblDownloads) {
        
        //Progressbar aanmaken
        final JTable table = tblDownloads;
        
        
        JProgressBar progress = new JProgressBar() {
            public boolean  isDisplayable() {
                //Om er voor te zorgen dat de animatie blijft lopen
                return true;
            }
            public void repaint(int row, int column) {
                //Om de cel te doen repainten
                ((DefaultTableModel)table.getModel()).fireTableCellUpdated(0,1);
          
            }          
        };
        
        progress.setIndeterminate(false);
        
        model.addRow(new Object[]{fileGet.toString(), progress,size.toString(),ipAddy.toString()});
        
       
        table.getColumnModel().getColumn(1).setCellRenderer( new TableCellRenderer() {
            
            public Component getTableCellRendererComponent(JTable table,Object value, boolean isSelected, boolean hasFocus, int row, int column) {
                if (value instanceof JComponent) {
                    return (JComponent)value;
                   
                } else {
                    return null;
                }
            }
        });


        //DownloadThread aanmaken
        Thread downloadingThread = new downloadingThread(ipAddy, fileGet, size, progress,table);
        
        //DownloadThread starten
        downloadingThread.start();
    }
}

//DownloadThread
class downloadingThread extends Thread {
    
    String ipAddy;
    String fileGet;
    String size;
    JProgressBar progress;
    int flag = 0;
    JLabel done;
    
    //Constructor
    public downloadingThread(Object ipa, Object fget, Object fsize, JProgressBar bar,JTable table){
        ipAddy = (String)ipa;
        fileGet = (String)fget;
        size = (String)fsize;
        progress = bar;
        table = table;
    }
    
    public void run() {
        try {
            
            //Connectie maken met de deler
            Socket connect = new Socket(ipAddy, 1000);
            
            //Input en Output instellen
            ObjectOutputStream outclient = new ObjectOutputStream(connect.getOutputStream());
            ObjectInputStream infrom = new ObjectInputStream(connect.getInputStream());
            
            //Download aanvragen
            outclient.writeObject(".download");
            outclient.writeObject(fileGet);
            
            //Progressbar minimum op 0 zetten
            progress.setMinimum(0);
            
            //Progressbar maximum op bestandsgrootte zetten
            progress.setMaximum(Integer.parseInt(size.toString()));
            
            //Wachten op het bestand
            while (true) {
                
                //Inlezen van de server
                Object get = infrom.readObject();
                
                switch (flag) {
                    
                    //Main case
                    case 0:
                        //Wachten op de file
                        if (get.equals(".startdownload")) {
                            
                            flag = 1;
                        }
                    case 1:
                        
                        //File wordt ingelezen
                        int data;
                        int totalDataRead; //Ingelezen data
                        int totalSizeWritten = 0; //Weggeschreven data
                        //int totalSizeRead; //Ingelezen
                        int PACKET_SIZE=2048; //Grootte van een pakketje
                        byte[] packet = new byte[PACKET_SIZE];//Een pakketje (array) bestaande uit bytes
                        
                        System.out.println("Bestand: " + fileGet);
                        String currentDirectory = System.getProperty("user.dir");
                        
                        //Hier nog een controle doorvoeren op eventuele bestaan , nu overschrijft hij identieke
                        
                        String uploaddirectory = currentDirectory + "\\share\\"+fileGet;
                        
                        //File wegschrijven naar de share directory
                        FileOutputStream fos = new FileOutputStream(uploaddirectory);
                        
                        //File byte per byte inlezen
                        while((totalDataRead = infrom.read(packet,0,packet.length)) >-1) {
                            //Data wegschrijven
                            fos.write(packet,0,totalDataRead);
                            //Hier wordt bepaald hoeveel reeds weggeschreven is
                            totalSizeWritten = totalSizeWritten + totalDataRead;
                            progress.setValue(totalSizeWritten);
                        }
                        
                        //Zeggen dat de download compleet is
                        done.setText("Download Complete");
                        
                        flag = 0;
                }
            }
        } catch (Exception e) {System.out.println(e);}
    }


}


Het probleem zit hem volgens mij hier:

code:
1
2
3
            public void repaint(int row, int column) {
                //Om de cel te doen repainten
                ((DefaultTableModel)table.getModel()).fireTableCellUpdated(0,1);


Ik zou daar alle cellen in die bepaalde kolom moeten kunnen updaten, daar had ik reeds een lus geplaatst maar dit hielp niet/

[ Voor 4% gewijzigd door Verwijderd op 29-12-2006 15:06 ]


Verwijderd

Mijn eerste reactie is een beetje: PaintComponent van die progresbar overriden?

Verwijderd

Topicstarter
Lukt me niet :(

Ligt het probleem daadwerkelijk bij die repaint of ik moet ik het elders zoeken?

Verwijderd

Topicstarter
Jammer genoeg heb ik geen probleem met mijn filetransfers.

  • latka
  • Registratie: Januari 2002
  • Laatst online: 13:01
Kijk eens naar http://java.sun.com/docs/...ng/concurrency/index.html: Swing is namelijk niet threadsafe. In JDK1.6 is SwingWorker standaard toegevoegd, voor andere JDKs moet je even googlen hoe je GUI updates doet vanuit een andere thread.

  • Robtimus
  • Registratie: November 2002
  • Laatst online: 01-12 19:51

Robtimus

me Robtimus no like you

SwingUtilities.invokeAndWait
SwingUtilities.invokeLater

Beiden nemen een Runnable die het werk voor je doet. Het verschil zit hem in de uitvoering: de eerste is blocking totdat de Runnable zijn werk heeft gedaan, en kan een InterruptedException of InvocationTargetException thrown. De tweede gaat meteen verder en throwt geen Exceptions.

More than meets the eye
There is no I in TEAM... but there is ME
system specs


Verwijderd

Topicstarter
Ik heb mijn probleem kunnen oplossen, indien gewenst post ik de hele boel eens.

  • TheRebell
  • Registratie: Oktober 2000
  • Laatst online: 01-12 14:11
hoi,

als je jouw oplossing (of hoe je het hebt opgelost) zou kunnen posten... :)
Ik ga namelijk zelf binnenkort ook verder met een progressbar en heb hier ook een tijd geleden wat problemen mee gehad.

Misschien helpt het trouwens ook andere mensen die een soortgelijk probleem hebben ermee :)

Verwijderd

Topicstarter
code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
//DownloadsTableModel.java
import java.util.*;
import javax.swing.*;
import javax.swing.table.*;

//Deze beheert de data in de tabel (download.java van voorgaand)
class DownloadsTableModel extends AbstractTableModel implements Observer {
    
    //Dit zijn de namen voor de kolommen, worden in een array gestoken
    private static final String[] columnNames = {"Bestand", "Grootte", "Voortgang", "Status"};
    
    //Dit zijn de klassen voor de waarden in de kolom 
    private static final Class[] columnClasses = {String.class, String.class, JProgressBar.class, String.class};
    
    //Een lijst van alle downloads
    private ArrayList downloadList = new ArrayList();
    
    //Een nieuwe download toevoegen
    public void addDownload(Download download) {
        
        //Deze klasse adden als observer
        download.addObserver(this);
        
        //Hier wordt er een download toegevoegd aan de ArrayList
        downloadList.add(download);//Object toevoegen
        
        //Nieuwe rij toevoegen in de tabel (download)
        fireTableRowsInserted(getRowCount() - 1, getRowCount() - 1);
    }
    
    //Download van een specifieke rij teruggeven
    public Download getDownload(int row) {
        return (Download) downloadList.get(row);
    }
    
    //Download uit de lijst verwijderen
    public void clearDownload(int row) {
        downloadList.remove(row);//Op basis van index
        
        //Download uit de tabel verwijderen
        fireTableRowsDeleted(row, row);
    }
    
    //Aantal kolommen ophalen
    public int getColumnCount() {
        return columnNames.length;
    }
    
    //Naam van een bepaalde kolom ophalen
    public String getColumnName(int col) {
        return columnNames[col];
    }
    
    //Klasse van een kolom ophalen
    public Class getColumnClass(int col) {
        return columnClasses[col];
    }
    
    //Aantal rijen ophalen
    public int getRowCount() {
        return downloadList.size();
    }
    
    //Waarde voor een bepaalde cel ophalen
    public Object getValueAt(int row, int col) {
        
        Download download = (Download) downloadList.get(row); //De download bepalen
        switch (col) {
            case 0: //Bestandsnaam
                return download.getName();
            case 1: //Bestandsgrootte
                String size = download.getSize();     
                return size + " kb"; //Mooi weergeven in kilobytes
            case 2: //Voortgang
                return new Float(download.getProgress());
            case 3: //Status
                return Download.STATUSES[download.getStatus()];
        }
        return "";
    }
    
    
    //Wordt opgeroepen bij NotifyObservers --> bij veranderingen
    public void update(Observable o, Object arg) {
        int index = downloadList.indexOf(o);
        //Updaten van de tabel
        fireTableRowsUpdated(index, index);
    }
}


en.
code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
//Download.java
import java.io.*;
import java.net.*;
import java.util.*;

// Vernieuwde klasse!!!! Dit is die thread die vorige keer in download.java werd opgeroepen
class Download extends Observable implements Runnable {
    
    //De Downloadstatussen
    public static final String STATUSES[] = {"Downloading","Complete"};
    
    //De codes van de downloadstatussen
    public static final int DOWNLOADING = 0;
    public static final int COMPLETE = 1;
    
    private int downloaded = 0; //Aantal gedownloade bytes
    private int status; //Huidige downloadstatus
    
    private String ipAddy; //IP adres waarnaar ik moet connecten
    private String fileGet; //De file die ik wil downloaden
    private String size; //De grootte van de file die ik wil downloaden
    private int flag = 0;
    
    //Constructor
    public Download(String ipAddy, String fileGet, String size) {
        this.ipAddy = ipAddy;
        this.fileGet = fileGet;
        this.size = size;
        status = DOWNLOADING;
        
        //Download beginnen
        download();
    }
    
    
    public String getName(){
        return fileGet;
    }
    
    //De grootte van het bestand weergeven
    public String getSize() {
        return size;
    }
    
    //De voortgang teruggeven
    public float getProgress() {
        return ((float) downloaded / Integer.parseInt(size)) * 100;
    }
    
    //De status doorgeven
    public int getStatus() {
        return status;
    }
    
    private void download() {
        Thread thread = new Thread(this);
        thread.start();
    }
    
    public void run() {
        
        
        try {
            
            //Connectie maken met de deler
            Socket connect = new Socket(ipAddy, 1000);
            
            //Input en Output instellen
            ObjectOutputStream outclient = new ObjectOutputStream(connect.getOutputStream());
            ObjectInputStream infrom = new ObjectInputStream(connect.getInputStream());
            
            //Download aanvragen
            outclient.writeObject(".download");
            outclient.writeObject(fileGet);
            
            //Wachten op het bestand
            while (true) {
                
                //Inlezen van de server
                Object get = infrom.readObject();
                
                switch (flag) {
                    
                    //Main case
                    case 0:
                        //Wachten op de file
                        if (get.equals(".startdownload")) {
                            
                            flag = 1;
                        }
                    case 1:
                        
                        //File wordt ingelezen
                        int data;
                        int totalDataRead; //Ingelezen data
                        int PACKET_SIZE=2048; //Grootte van een pakketje
                        byte[] packet = new byte[PACKET_SIZE];//Een pakketje (array) bestaande uit bytes
                        
                        System.out.println("Bestand: " + fileGet);
                        String currentDirectory = System.getProperty("user.dir");
                        
                        //Hier nog een controle doorvoeren op eventuele bestaan , nu overschrijft hij identieke
                        
                        String uploaddirectory = currentDirectory + "\\share\\"+fileGet;
                        
                        //File wegschrijven naar de share directory
                        FileOutputStream fos = new FileOutputStream(uploaddirectory);
                        
                        //File byte per byte inlezen
                        while((totalDataRead = infrom.read(packet,0,packet.length)) >-1) {
                            //Data wegschrijven
                            fos.write(packet,0,totalDataRead);
                            //Hier wordt bepaald hoeveel reeds weggeschreven is
                            downloaded = downloaded + totalDataRead;
                            
                            stateChanged();
                            //progress.setValue(totalSizeWritten);
                        }
                        
                        //Zeggen dat de download compleet is
                        status = COMPLETE;
                        stateChanged();
                        
                        flag = 0;
                }
            }
        } catch (Exception e) {
            System.out.println(e)
            ;}


    }
    
    //De status steeds updaten
    private void stateChanged() {
        setChanged();
        notifyObservers();
    }
}


code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
//ProgressRenderer.java
import java.awt.*;
import javax.swing.*;
import javax.swing.table.*;

// This class renders a JProgressBar in a table cell.
class ProgressRenderer extends JProgressBar
        implements TableCellRenderer {
    
    // Constructor for ProgressRenderer.
    public ProgressRenderer(int min, int max) {
        super(min, max);
    }
    
  /* Returns this JProgressBar as the renderer
     for the given table cell. */
    public Component getTableCellRendererComponent(
            JTable table, Object value, boolean isSelected,
            boolean hasFocus, int row, int column) {
        // Set JProgressBar's percent complete value.
        setValue((int) ((Float) value).floatValue());
        return this;
    }
}



Ik had wel nog een vraagje. Ik heb een tblResults met een DefaultTableModel, maar ik zou graag hebben dat die items in de cells niet editable zijn, wel enkel selectable. Enige idee met welke property ik dit doe?

  • Robtimus
  • Registratie: November 2002
  • Laatst online: 01-12 19:51

Robtimus

me Robtimus no like you

Java:
1
2
3
4
5
model = new DefaultTableModel(....) {
    public boolean isCellEditable(int row, int column) {
        return false;
    }
};
Met andere woorden: je maakt een anonieme subclass van DefaultTableModel die 100% hetzelfde werkt behalve die ene method. Je kunt zelfs op basis van de column true of false returnen.

Een andere method die je trouwens vaak kan overwriten is "public Class getColumnClass(int columnIndex)". Standaard returnt deze Object.class voor alle columns, wat leidt tot text field in de cellen die de inhoud als tekst behandeld. Als je Boolean.class returnt krijg je een check box ipv een text field, en Number.class of Integer.class zal de text anders weergeven in het text field van de cell (right aligned ipv left).

Uitgebreider voorbeeld:
Java:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
model = new DefaultTableModel(....) {
    public boolean isCellEditable(int row, int column) {
        return column == 0 || column == 4;
    }

    public Class getColumnClass(int column) {
        switch (column) {
            case 0:
                return Boolean.class;
            case 1:
                return Integer.class;
            case 4:
                return Date.class;
            default:
                return super.getColumnClass(column); // of return Object.class
        }
    }
};

More than meets the eye
There is no I in TEAM... but there is ME
system specs


Verwijderd

Topicstarter
Deze heb ik gebruikt, maar wanneer ik dubbelklik kan ik de inhoud van de cel nog steeds wijzigen.
Ik gebruik dit voor een peer 2 peer programma dat ik aan het schrijven ben, dus ik zou een tabel moeten krijgen met een hele hoop files die ik uiteraard niet zou mogen kunnen wijzigen. Ook zou ik een hele rij ineens moeten selecteren en niet gewoon één cel.

Java:
1
2
3
4
5
6
7
         
            //Tabel voor downloads
            tableModel = new DownloadsTableModel(){
                public boolean isCellEditable(int row, int column) {
                    return false;
                }
            };

Verwijderd

Topicstarter
Het is mij dus nog altijd niet gelukt om de cellen in mijn tabel uneditable te maken, volgens mij staat die methode die hier bovenaan gepost staat toch op de juiste plaats?

Java:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
    public void opstarten(){
        try{
            //Melding voor poort!
            JOptionPane.showMessageDialog(this,"Zorg dat je poort 9999 openstaat!");
            
            //Server IP ingeven
            server = JOptionPane.showInputDialog(null,"Server IP adres:","127.0.0.1");
            
            //Share mapje aanmaken als het nog niet bestaat!
            String currentDirectory = System.getProperty("user.dir");
            File sharemap = new File(currentDirectory +"\\share");
            if(sharemap.exists()){
                //Ok
            }else{
                //Aanmaken
                sharemap.mkdir();
            }
            
            
            
            //Lokaal IP adres ophalen
            InetAddress addr = InetAddress.getLocalHost();
            String ipAddr = addr.getHostAddress();
            
            //Lokaal IP adres bijhouden
            final ipaddressgetset ipags = new ipaddressgetset();
            ipags.setIp(ipAddr);
            
            //Als de gebruiker niet correct afsluit moeten we de server toch
            //nog meedelen dat hij uitgelogd is om fouten te voorkomen
            Runtime.getRuntime().addShutdownHook(new Thread() {
                public void run() {
                    try {
                        
                        //Server checken
                        if (server != null) {
                            
                            //.deleteme roept de "deletme" functie op de server op
                            out.writeObject(".deleteme");
                            
                            //Gebruiker zijn IP adres doorsturen zodat de server weet wat hij moet deleten
                            out.writeObject(ipags.getIp());
                            
                            //De stream afsluiten
                            out.close();
                            
                        }
                        
                    } catch(Exception ex) {}
                }
            });
            
            
            //Menu opmaken
            JMenuBar menuBar = new JMenuBar();
            //menuBar.setBackground(new java.awt.Color(204, 204, 255));
            setJMenuBar(menuBar);
            
            JMenu mFile = new JMenu("Bestand");
            mFile.setMnemonic('b');
            
            JMenuItem miConnect = new JMenuItem("Verbinden");
            miConnect.setMnemonic('v');
            
            JMenuItem miExit = new JMenuItem("Afsluiten");
            miExit.setMnemonic('a');
            
            mFile.add(miConnect);
            mFile.add(miExit);
            
            menuBar.add(mFile);
            
            //Tabel voor resultaten opmaken
            tblResults.setModel(model);
            tblResults.setBackground(Color.WHITE);
            
            //Tabel voor downloads
            tableModel = new DownloadsTableModel(){
                public boolean isCellEditable(int row, int column) {
                    return false;
                }
            };
            
            
            tblDownloads.setModel(tableModel);
            tblDownloads.setBackground(Color.WHITE);
            tblDownloads.setSelectionMode(0);
            
            
            //Kolomheaders toevoegen
            model.addColumn("Bestandsnaam");
            model.addColumn("Type");
            model.addColumn("Ip Adres");
            model.addColumn("Grootte (kb)");
            
            
            //Progressrenderer instellen
            ProgressRenderer renderer = new ProgressRenderer(0, 100);
            renderer.setStringPainted(true); //Progressie weergeven in tekst ook
            tblDownloads.setDefaultRenderer(JProgressBar.class, renderer);
            
            
            //Verbinding maken met de server
            miConnect.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    try {
                        
                        //IP adres ophalen
                        String ipgotten = ipags.getIp();
                        
                        //Server IP ingeven via inputdialog
                        //server = JOptionPane.showInputDialog(null,"Server IP adres:","127.0.0.1");
                        
                        //Client socket aanmaken
                        client = new Socket(server, 10000);
                        
                        //Outputstream instellen
                        out = new ObjectOutputStream(client.getOutputStream());
                        
                        //Gebruikersdirectory ophalen
                        String currentDirectory = System.getProperty("user.dir");
                        
                        //Gedeelde map ophalen
                        File dir = new File(currentDirectory + "\\share");
                        
                        //Een lijst maken van de gedeelde bestanden
                        File[] list = dir.listFiles();
                        
                        //Al deze info doorsturen naar de server
                        for(int ii = 0; ii < list.length; ii++) {
                            String outfile = list[ii].getName().toString();
                            //IP doorsturen
                            out.writeObject(".ip");
                            out.writeObject(ipgotten);
                            
                            //Bestandsnaam doorsturen
                            out.writeObject(".gofile");
                            out.writeObject(outfile);
                            
                            //Bestandsgrootte doorsturen
                            out.writeObject(".filesize");
                            out.writeObject(String.valueOf(list[ii].length()));
                            
                            //Bestandstype (later nog uitwerken!!!)
                            out.writeObject(".type");
                            String fileType = type.getType(outfile);
                            
                            out.writeObject(fileType);
                            
                            //Alles doorgestuurd!
                            out.writeObject(".done");
                            
                            //Spacer zenden (pause)
                            out.writeObject("Spacer");
                            
                            //Status op verbonden zetten!
                            setStatus("Status: Verbonden!");
                        }
                    } catch (Exception ae) {
                        System.out.println(ae);
                        setStatus("Status: Niet Verbonden!");
                    }
                    setStatus("Status: Niet Verbonden!");
                }
                
            }
            );
            
            
            //Programma afsluiten
            miExit.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent ae) {
                    
                    //Als het IP adres gekend is
                    if (server != null) {
                        try {
                            
                            //Verbinding maken met server
                            client = new Socket(server, 10000);
                            
                            //Outputstream instellen
                            out = new ObjectOutputStream(client.getOutputStream());
                            
                            //Al mijn files van de server halen
                            out.writeObject(".deleteme");
                            out.writeObject(ipags.getIp());
                            
                            //Stream sluiten
                            out.close();
                            
                        } catch(Exception e){}
                    }
                    
                    //Afsluitenboodschap
                    JOptionPane.showMessageDialog(null,"Bedankt om gebruik te maken van DevShare!","Bedankt",JOptionPane.PLAIN_MESSAGE);
                    
                    //Afsluiten
                    System.exit(0);
                }
            }
            );
            
            
            
            
        }catch (Exception exc){
        }
    }
    

Verwijderd

Topicstarter
Ik heb het probleem na veel vijzen en zessen dan toch kunnen oplossen:

Java:
1
2
3
4
5
6
7
8
9
10
11
12
   //Tabel voor resultaten opmaken
            
            model = new DefaultTableModel(){
                public boolean isCellEditable(int row, int column) {
                
                    return false;
                }
            };
            
            tblResults.setModel(model);
            tblResults.setBackground(Color.WHITE);
            


Maar nu zou ik graag hebben dat wanneer ik een cel selecteer automatisch die hele rij geselecteerd wordt, ik heb hiervoor rowselectionalowed en rowselectioninterval reeds toegepast maar zonder resultaat.

  • Robtimus
  • Registratie: November 2002
  • Laatst online: 01-12 19:51

Robtimus

me Robtimus no like you

Wat dacht je van column selection allowed? ;)
Java:
1
2
3
table.setColumnSelectionAllowed(false);
table.setRowSelectionAllowed(true);
table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);

Deze combinatie gebruik ik zelf ook, werkt prima.

More than meets the eye
There is no I in TEAM... but there is ME
system specs

Pagina: 1