[JAVA] custom JTable cellRender lento: come velocizzare?

[redcloud]

Ho la necessità di cambiare dei colori all'interno di una cella di una JTable. Seguendo qualche thread ho capito che bisogna estendere la classe DefaultTableCellRenderer. Ne ho creata una mia e ho sovrascritto il metodo getTableCellRendererComponent...

public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
	Border border;

	super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
		
	if(true) {
               //QUALCOSA DI NON COMPLESSO CHE MODIFICA BORDER
	}
	this.setBorder(border);
		
	super.setVerticalAlignment(SwingConstants.TOP);
		
	return this;
}

e poi questo renderer lo uso così

table.getColumnModel().getColumn(z).setCellRenderer(new TableColorRenderer());

Funziona egregiamente, peccato però che mi rallenta in modo spropositato la visualizzazione della tabella. Utilizzando il renderer di default, la tabella viene visualizzata in un attimo, con il mio renderer invece i tempi triplicano, quadruplicano! Ho provato a lasciare vuoto il metodo getTableCellRendererComponent

public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
	super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
		
	return this;
}

ma i tempi sono gli stessi! Vorrei capire se ciò è dovuto a qualche mio errore fatto in questo tipo di costrutto oppure non è questo il modo di creare un renderer custom. Molte grazie!

[^TiGeRShArK^]

Io non mi sono mai messo a bestemmiare con i cell renderer qdi mi sa che devi aspettare il buon vecchio ( ) PGI...
Però puoi provare ad attivare la pipeline directx e vedere se hai qualke miglioramento...
l'opzione che devi passare alla VM è la seguente:
-Dsun.java2d.d3d=true
però non mi ricordo se è stata introdotta in java 6 o era presenta anche nella 5
vabbè.. prova lo stesso che tanto ci metti 3 secondi netti

[redcloud]

Originariamente inviato da ^TiGeRShArK^

Io non mi sono mai messo a bestemmiare con i cell renderer qdi mi sa che devi aspettare il buon vecchio ( ) PGI...
Però puoi provare ad attivare la pipeline directx e vedere se hai qualke miglioramento...
l'opzione che devi passare alla VM è la seguente:
-Dsun.java2d.d3d=true
però non mi ricordo se è stata introdotta in java 6 o era presenta anche nella 5
vabbè.. prova lo stesso che tanto ci metti 3 secondi netti

Grazie ma non c'entra questo (purtroppo!). Ho trovato questo articolo interessante ma non ho ancora capito come risolvere.

http://java.sun.com/docs/books/perfo...Models.fm.html

[PGI-Bis]

Quell'articolo tratta dell'ovvio.

La cosa bizzarra nel tuo codice è:

super.getTableCell eccetera
return this;

dovrebbe essere:

return super.getTableCellRendererComponent(eccetera)

Ma se questo è la causa del problema mi taglio i baffi. La classe è tutta lì?

[redcloud]

Originariamente inviato da PGI-Bis

Quell'articolo tratta dell'ovvio.

La cosa bizzarra nel tuo codice è:

super.getTableCell eccetera
return this;

dovrebbe essere:

return super.getTableCellRendererComponent(eccetera)

Ma se questo è la causa del problema mi taglio i baffi. La classe è tutta lì?

Si è tutta lì, quello è l'unico metodo sovraccaricato. Anche io credevo di dover fare return super.getTable.... ma così facendo le modifiche non hanno effetto e in più, le performance sono improponibili ugualmente! Insomma, basta sovraccaricare quel metodo e le performance degradano paurosamente... mi tocca andare a vedere com'è il sorgente del default renderer?

[PGI-Bis]

Hai provato a "lascia scorrere" l'applicazione? Forse devi solo aspettare che il JIT la mastichi per bene.

Il fatto è che un semplice overload non può essere causa di per sè di un aggravio percepibile. E Swing è tutto Java, non ci sono "punti magici" o che altro. Magari è un bug di Swing o è la scheda video. Hai i driver aggiornati?

[redcloud]

Ho provato a sovraccaricare il metodo così:

public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
      return super.getTableCellRendererComponent(table, value,
                                                 isSelected,
                                                 hasFocus,
                                                 row, column);
}

4 secondi per visualizzare la JTable! Se invece lascio il default renderer, impiega meno di mezzo secondo...


Con questo codice invece i tempi sono gli stessi del renderer di default

public class FastStringRenderer extends DefaultTableCellRenderer {

   Component stubRenderer = new NothingComponent();

   public Component getTableCellRendererComponent(JTable table,
                                                  Object value,
                                                  boolean isSelected,
                                                  boolean hasFocus,
                                                  int row, 
                                                  int column) {

      return super.getTableCellRendererComponent(table, value,
                                                 isSelected,
                                                 hasFocus,
                                                 row, column);
   }

   class NothingComponent extends JComponent {
      public void paint(Graphics g) {
         // Do Nothing
      }
   }
}

preso da http://java.sun.com/docs/books/perfo...m.html#1009068

[PGI-Bis]

Porta il tuo PC dall'esorcista perchè quelle due cose sono fisicamente identiche.

Anche tu estendi DefaultTableCellRenderer, no?

[redcloud]

Scusa ho modificato il codice. Ora il senso dovrebbe essere giusto.

public class FastStringRenderer extends DefaultTableCellRenderer {

   Component stubRenderer = new NothingComponent();

   public Component getTableCellRendererComponent(JTable table,
                                                  Object value,
                                                  boolean isSelected,
                                                  boolean hasFocus,
                                                  int row, 
                                                  int column) {

      return stubRenderer;
   }

   class NothingComponent extends JComponent {
      public void paint(Graphics g) {
         // Do Nothing
      }
   }
}

Originariamente inviato da PGI-Bis

Anche tu estendi DefaultTableCellRenderer, no?

Si certo.

[PGI-Bis]

Calma e gesso. Ma tu fai una comparazione della rapidità tra una tabella vuota e una con tutti i disegnini o tra due tabelle uguali?

Lo chiedo perchè la rapidità del renderer standard sta tutta nel fatto che il renderer standard... non fa un cacchio. Disegna una stringa, bella forza, così son buoni tutti. E' chiaro che più disegni e più è "pesante" l'esecuzione rispetto alla versione che quei disegni non li fa.

Detto questo, il limite di carico è piuttosto alto, nel senso che, per com'è fatto il meccanismo, puoi sbizzarrirti artisticamente. Esattamente il tuo renderer com'è fatto?

[redcloud]

E' proprio questo il punto! Se alla JTable lascio il DefaultTableCellRenderer, i tempi sono veloci. Se invece assegno il mio renderer, per visualizzare una stessa tabella (cioè gli stessi dati, i colori ovviamente il renderer di default non li gestisce, e si tratta solo di mettere un bordo sul 2% delle 30000 celle totali) impega 4 secondi.

Il renderer sovraccaricato più efficiente possibile è questo (credo, è stato ideato per rendere ancora più efficiente quello di default)

public class FastStringRenderer extends DefaultTableCellRenderer {

   Component stubRenderer = new NothingComponent();

   public Component getTableCellRendererComponent(JTable table,
                                                  Object value,
                                                  boolean isSelected,
                                                  boolean hasFocus,
                                                  int row, 
                                                  int column) {

      if ( ((String)value).length() == 0 && 
           !isSelected && !has-Focus) {
         return stubRenderer;
      }

      return super.getTableCellRendererComponent(table, value,
                                                 isSelected,
                                                 hasFocus,
                                                 row, column);
   }

   class NothingComponent extends JComponent {
      public void paint(Graphics g) {
         // Do Nothing
      }
   }
}

Questo è il sorgente di DefaultTableCellRenderer

public Component getTableCellRendererComponent(JTable table, Object value,
                          boolean isSelected, boolean hasFocus, int row, int column) {

	if (isSelected) {
	   super.setForeground(table.getSelectionForeground());
	   super.setBackground(table.getSelectionBackground());
	}
	else {
	    super.setForeground((unselectedForeground != null) ? unselectedForeground 
	                                                       : table.getForeground());
	    super.setBackground((unselectedBackground != null) ? unselectedBackground 
	                                                       : table.getBackground());
	}
	
	setFont(table.getFont());

	if (hasFocus) {
            Border border = null;
            if (isSelected) {
                border = UIManager.getBorder("Table.focusSelectedCellHighlightBorder");
            }
            if (border == null) {
                border = UIManager.getBorder("Table.focusCellHighlightBorder");
            }
            setBorder(border);

	    if (!isSelected && table.isCellEditable(row, column)) {
                Color col;
                col = UIManager.getColor("Table.focusCellForeground");
                if (col != null) {
                    super.setForeground(col);
                }
                col = UIManager.getColor("Table.focusCellBackground");
                if (col != null) {
                    super.setBackground(col);
                }
	    }
	} else {
            setBorder(getNoFocusBorder());
	}

        setValue(value); 

	return this;
    }

Se uso quello di default, problemi non ce ne sono. Se uso quello efficiente impiega 4 secondi contro pochi decimi! Quindi l'errore non è nel codice del renderer. Forse sbaglio a settare il renderer? Io lo setto così:

JTable table = new JTable();

table.getColumnModel().getColumn(0).setCellRenderer(new FastStringRenderer());

[PGI-Bis]

Lascia stare quello che scrivono gli altri, anche se lo scrivono su Sun. Su Sun hanno scritto di quelle pacchianate che non hai idea. Non so se ricordi la bufala "Java è un mix di passaggio per riferimento e per valore", be' era scritta sul sito di Sun e su un manuale rilasciato da Sun.

Tu cosa hai scritto. Com'è fatta la tua classe, per intero con annessi e connessi. Funziona? Benissimo, sei al 99% del risultato. Forse all'interno di quella classe c'è un calcolo che sembra innocuo ma ripetuto su mila celle genera un ritardo apprezzabile. Si può precomputare il risultato? Vediamo la classe. Non avere alcun timore, io ho studiato legge per cui sono l'essere informaticamente meno autorevole a cui si possa pensare. Tutto posso fare tranne criticare il codice altrui.

[redcloud]

Porca trota! Il problema è nell'assegnazione del renderer. Non mi ero accorto che lo facevo per ogni riga della tabella! Invece bisogna farlo una sola volta per ogni colonna, indipendentemente dal numero di righe! Che pirlaz! Grazie per il supporto morale notturno ++Birra per te