[JAVA - SWING]

[tylerdurden83]

Ciao a tutti. Dopo ore passate a scervellarmi non mi resta che ricorrere al vostro aiuto...

In breve (se necessario domani posto il codice).

Sul DB:

Nome          Flag
Qui             1
Quo             1
Qua             1

Ho un JFrame con una JTable dentro. La struttura del table model è composta dal nome e da un JButton ad esso associato, ed è riempito facendo una select sul DB where flag=1.

Quindi inizialmente:

Nome       JButton     
Qui            JButton_Qui
Quo            JButton_Quo
Qua            JButton_Qua

Ho correttamente creato un renderer ed un editor per JButton.Class, in modo da visualizzarli e cliccarli correttamente (ie, le ActionEvent sono innescate correttamente).

Il problema sorge quando vado ad eliminare una riga e ridisegnare il tutto. In particolare, facciamo finta che premo il bottone JButton_Qui. Viene scatenata una actionEvent che fa:
update mia_tabella set flag=0 where nome = qui

E anche fino a qui ci siamo. A questo punto pulisco il defaultTableModel per levare i dati caricati al giro precedente (con .clear()) e rilancio il metodo che ha caricato nella table/model i dati in precedenza, aspettando che non carichi piu Qui, in quanto il flag di Qui non è più ad 1.

Questo il risultato:

Nome       JButton     
Quo            JButton_Qui
Qua            JButton_Qua

In pratica, il bottone a fianco a Quo, è quello che avevo premuto in precedenza... Non riesco a risolvere il problema. Il nuovo tableModel contiene solo Quo e Qua. I nuovi JButton.setActionListener sono invocati correttamente e tutto il resto...

Come sempre, grazie a tutti per l'aiuto!

[banryu79]

Mi sa che è meglio se posti il codice...

[tylerdurden83]

Magari tra poco lo posto, non l' ho fatto prima perchè le classi impattate sono molte. Tuttavia, mi pare di aver risolto spostando

implements ActionListener

dalla classe

public class MyCellEditor extends AbstractCellEditor implements TableCellEditor, ActionListener {

alla classe "principale". Il motivo per cui avevo messo ActionListener insieme alla classe Editor era per poter chiamare fireEditingStopped();

Tuttavia ho letto che quando succede un problema tipo quello che ho descritto nel post precedente, è dovuto al fatto che la cella contenente il bottone (la sola che "scala" male) è ancora selezionata (e pensavo che fireEditingStopped(); la deselezionasse...).

Ho spostato ActionListener alla classe principale, levato fireEditingStopped e aggiunto table.getCellEditor().stopCellEditing();

Ora pare che vada, faccio altre prove. Intanto, se la cosa per te ha senso, mi piacerebbe capirla

Grazie,
TD

EDIT: come non detto, ora da Exception in thread "AWT-EventQueue-0" java.lang.ArrayIndexOutOfBoundsException: 0 >= 0

[banryu79]

Originariamente inviato da tylerdurden83

Ora pare che vada, faccio altre prove. Intanto, se la cosa per te ha senso, mi piacerebbe capirla

Mi piacerebbe aiutarti, ma a dire il vero anche se in questo periodo sto studiando Swing non sono ancora arrivato a cimentarmi con le JTable in modo profondo (che poi, a parte la conoscenza di Swing nel suo complesso, nello specifico è lo scopo mirato del mio studio).

Chiedevo di postare del codice perchè in genere in questo modo è più facile per gli altri capire e aiutarti a trovare l'errore.

@EDIT:
Non ho capito se hai un problema legato al corretto uso del modello degli eventi di Swing o se legato ad una corretta implementazione dell'editor di qualche componente...

[tylerdurden83]

Parti importanti di codice:

// classe principale
class JavaTecConsole extends TablesGeneric implements Runnable, ActionListener {  
		
    @Override public void actionPerformed(ActionEvent e) {
        System.out.println(e.getActionCommand());
        try {
            // mette il flag relativo al nome cliccato a 0 sul DB cosi non viene piu ricaricato
            Utilities.doUpdate(Long.parseLong(e.getActionCommand()));
            synchronized (this.datiRighe){
                this.datiRighe.notifyAll();
            }
    }

    @Override void createVector(Event event){
        Vector<Object> vector = new Vector<Object>();
        vector.addElement(event.getHostname());
        // aggiunge i vari element, e per finire il bottone
        JButton startButton = new JButton("Close"+event.getId());
        startButton.setActionCommand(String.valueOf(event.getId()));
        startButton.addActionListener(this);
        vector.addElement(startButton);
        // datiRighe è un defaulttablemodel definito in TablesGeneric
        this.datiRighe.add(0, vector);
    }

    @Override public void run() {
        try {
            makeUI();
            this.setLocation(0,223);
            this.pack();
            this.setVisible(true);  
            this.getContentPane().validate();
            this.addWindowListener(new WindowAdapter() {      
                @Override public void windowClosing(WindowEvent e) {        
                    stoppato=true;
                }
            }); 
            List<Event> eventList = null;// doSelect();
            while (stoppato==false) {
                datiRighe.clear();
                eventList = doSelect();
                Iterator<Event> it = eventList.iterator();
                while (it.hasNext()){
                    Event event = it.next();
                    int totaleRighe = datiRighe.size();
                    if (totaleRighe == 400){
                        datiRighe.remove(399);
                        model.rowsRemoved(new TableModelEvent (table.getModel(), 0, table.getRowCount(), 7, TableModelEvent.DELETE));
                    }
                    createVector(event);
                    model.newRowsAdded(new TableModelEvent (table.getModel(), 0, 0, TableModelEvent.ALL_COLUMNS, TableModelEvent.INSERT));
                }
                this.mce.setDatiRighe(this.datiRighe);
                synchronized (this.datiRighe) {
                    this.datiRighe.wait(1000000L);
                }
            }

In TablesGeneric:

this.datiRighe = new Vector<Vector<Object>>();
        // create the DefaultTableModel with the vector of vectors to hold row 
        // data, and the vector of column names
        this.model = new DefaultTableModel(this.datiRighe, columnNames2);
        // create the jtable using the DefaultTableModel
        this.table = new JTable(this.model){
            // this method is necessary in order to render properly the objects in the cells
            // with this, the appropriate renderer will be used
            // without this, the only way to render stuff properly would be to specify the type 
            // of renderer to use for each different column
            @Override
            public Class getColumnClass(int column) {
                return getValueAt(0, column).getClass();
            }
        };
        // install the default renderer and editor for all MyJButton objects stored in the table
        //this.table.setDefaultRenderer(MyJButton.class, new MyJButtonRenderer());
        //this.table.setDefaultEditor(MyJButton.class, new MyCellEditor());
        this.table.setDefaultRenderer(JButton.class, new MyJButtonRenderer());
        this.table.setDefaultEditor(JButton.class, new MyCellEditor());

Il renderer per i JButton:

public class MyJButtonRenderer extends JButton 
        implements TableCellRenderer {
    
    private String buttonText="";
    private Border selectedBorder = null;
    private Border unselectedBorder = null;
    
    public MyJButtonRenderer(String s){
        this.buttonText=s;
    }
    
    public MyJButtonRenderer(){
    }

    @Override
    public Component getTableCellRendererComponent(
                            JTable table, Object value,
                            boolean isSelected, boolean hasFocus,
                            int row, int column) {
        
        if (isSelected) {
            if (selectedBorder == null) {
                selectedBorder = BorderFactory.createMatteBorder(2,5,2,5,
                                          table.getSelectionBackground());
            }
            setBorder(selectedBorder);
        } else {
            if (unselectedBorder == null) {
                unselectedBorder = BorderFactory.createMatteBorder(2,5,2,5,
                                          table.getBackground());
            }
            setBorder(unselectedBorder);
        }
        setText( (value == null) ? "" : ((JButton)value).getText());
        setToolTipText("RGB value: ");
        return this;
    }    
}

e l'editor:

public class MyCellEditor extends AbstractCellEditor 
        implements TableCellEditor {
    
    public MyCellEditor(){
    }
    
    private JavaTecConsole jtc;
    private Vector<Vector<Object>> datiRighe;
    private JTable jtable;
    
    void setJTC(JavaTecConsole jtc){
        this.jtc=jtc;
    }
    
    void setJTable(JTable jt){
        this.jtable=jt;
    }
    
    void setDatiRighe(Vector<Vector<Object>> datiRighe){
        this.datiRighe=datiRighe;
        if (this.jbutton!=null)
                System.out.println("JButton AE="+this.jbutton.getActionCommand());
    }
            
    MyCellEditor(JavaTecConsole jtc){
        this.jtc=jtc;
    }

    private JButton jbutton;
    private String text;
    @Override
    public Component getTableCellEditorComponent(JTable table, Object value, boolean isSelected, int row, int column) {
        text = (value == null) ? "" : ((JButton)value).getText();
        jbutton = (JButton)value;
        return jbutton;
    }
	
    @Override
    public Object getCellEditorValue() {
        return this.jbutton;
    }
}