Affichage instable avec les composants SWING

Bonjour,

Je suis bloque sur un problem que je n'arrive pas resoudre:

J'ai une fenetre JFrame avec un composant JTable dedans, cette JTable
utilise un TableCellRenderer personnalise. Tout va bien et tout fonctionne
a merveil, sauf que quand je veux afficher une deuxime fenetre du type
JDialog ayant comme fenetre mere la JFrame principale, les deux fenetres
(la JFrame et la JDialog) deviennet totalement instables, les differents
composants (JButton, JList, etc.) des fenetres s'affichent a moitie et c'est
pas jolie du tout...

J'ai fait un test et j'ai desactive la rendu (TableCelleRenderer) de la JTable
et hop, tout va bien les deux fenetres s'affichent correctement.

Y'a t-il un moyen d'utiliser un TableCelleRenderer personnalise de sorte
que ca ne creer pas d'instablilite sur le fonctionnement d'affichage des
fenetres en Java.

D'apres ce que j'ai compris la TableCelleRenderer tourne en continue dans
la JVM et effectue les changements necessaires a la JTable, c'est comme s'il bouclait dans la JVM et je pense que c'est ca qui rends l'affichage instable...

Merci d'avance pour votre aide,

ValFajr.

Eh bien apparemment tu as commis une grave erreur dans ton TableCelleRenderer. Il faudrait que tu nous montres ton code source.

Voici mon code:

..........

final String[] columns = {"ID", "Name", "Val", "Type", "Mon", "State"};
final Object[][] data = new Object[30][6];

class MyCellRendererGreen extends DefaultTableCellRenderer {
public Component getTableCellRendererComponent(JTable table,Object value,
boolean isSelected,boolean hasFocus,int row,int column) {
JLabel label = (JLabel) super.getTableCellRendererComponent(table,value,isSelected,hasFocus,row,column);
setBackground(Color.green) ;
table.repaint() ;
return label ;
}
}

class MyCellRendererRed extends DefaultTableCellRenderer {
public Component getTableCellRendererComponent(JTable table,Object value,
boolean isSelected,boolean hasFocus,int row,int column) {
JLabel label = (JLabel) super.getTableCellRendererComponent(table,value,isSelected,hasFocus,row,column);
setBackground(Color.red) ;
table.repaint() ;
return label ;
}
}

final TableCellRenderer myCellRendererGreen = new MyCellRendererGreen();
final TableCellRenderer myCellRendererRed = new MyCellRendererRed();

table = new JTable(data, columns) {
public TableCellRenderer getCellRenderer(int row, int column) {

if ((table.getValueAt(row, 5) != null)) {
if (table.getValueAt(row, 5).equals("ON")) return myCellRendererGreen ;
if (table.getValueAt(row, 5).equals("OFF")) return myCellRendererRed ;
}
return super.getCellRenderer(row, column);
}
};

table.setPreferredScrollableViewportSize(new Dimension(650, 300));
table.getTableHeader().setReorderingAllowed(false);
table.setOpaque(true) ;

table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);

ListSelectionModel rowSM = table.getSelectionModel();
rowSM.addListSelectionListener(new ListSelectionListener() {
public void valueChanged(ListSelectionEvent e) {
//Ignore extra messages.
if (e.getValueIsAdjusting()) return;
ListSelectionModel lsm = (ListSelectionModel)e.getSource();
if (lsm.isSelectionEmpty()) {
System.out.println("No rows are selected.");
turn(false) ;
} else {
int selectedRow = lsm.getMinSelectionIndex();
currentSelection = (String) table.getValueAt(selectedRow, 1) ;
if (currentSelection != null) {
currentRow = selectedRow ;
turn(true) ;
}
else {
turn(false) ;
}
System.out.println("selected= "+currentSelection);
}
}
});


............


Merci,

Arf, c'etait juste a cause des repaint() dans les deux classes TableCelleRenderer.

En fait vu que la les instances des classes TableCelleRenderer tournent en continue dans la JVM et qu'elle comportaient un repaint() ca faisait repaint() en boucle sur la JTable et ca rendait l'affichage instable .

J'ai enlevait les repaint() et tout va bien :D

Par contre je ne comprends pas pourquoi ils ont complique a ce point la personnalisation des JTable. Car changer la couleur d'une ligne dans une JTable a mon humble avis ne doit pas avoir besoin de la creation de tout un ensemble de nouvelles classes :roll:

A++
Val.

Je ne comprends pas ce que tu veux dire par "tournent en continu". Effectivement tu réalisais une boucle infinie. Enfin si cela peut paraître un peu lourd pour changer une couleur, tu verras rapidement que c'est extrêmement puissant et que JTable permet de faire des choses assez impressionnantes grâce à ce sytème.

J'ai trouve ceci dans la javadoc sur le site de sun:

Class DefaultTableCellRenderer

Implementation Note: This class inherits from JLabel, a standard component class. However JTable employs a unique mechanism for rendering its cells and therefore requires some slightly modified behavior from its cell renderer. The table class defines a single cell renderer and uses it as a as a rubber-stamp for rendering all cells in the table; it renders the first cell, changes the contents of that cell renderer, shifts the origin to the new location, re-draws it, and so on. The standard JLabel component was not designed to be used this way and we want to avoid triggering a revalidate each time the cell is drawn. This would greatly decrease performance because the revalidate message would be passed up the hierarchy of the container to determine whether any other components would be affected. As the renderer is only parented for the lifetime of a painting operation we similarly want to avoid the overhead associated with walking the hierarchy for painting operations. So this class overrides the validate, invalidate, revalidate, repaint, and firePropertyChange methods to be no-ops and override the isOpaque method solely to improve performance. If you write your own renderer, please keep this performance consideration in mind.


D'apres ce que je comprend le Renderer est une sorte de Thread qui tourne en continue dans la JVM est fait des modifs quand necessaires. Par exemple dans mon cas j'avais specifie que si la valeur d'une cellule devient egale a "ON" alors changer la couleur de la ligne a laquelle la cellule appartien. Si la Renderer n'est pas une Thread qui tourne en continu dans la JVM alors je ne voit pas comment elle peut savoir qu'il y a eu modifs et qu'elle doit intervenir... D'ailleur c'est pour cela que tout ce que tu met dans la Renderer sera execute en boucle 8-)

A++
Val.

Je ne vois pas ce qui dans cette documentation te fait penser qu'il s'agit d'une sorte de thread. Les renderers ne tournent pas en continue et ne sont invoqués que lorsque cela est nécessaire. La JTable est responsable pour les invoquer au bon moment. Quand tu appelles table.repaint(), les renderes sont appelés... et comme tu appelais table.repaint() dans ton renderer tu rappellais ton propre renderer qui rappelait table.repaint(), etc.

Peut etre que tu as raison, mais alors ce que je ne comprend pas c'est que meme si au lieu de repaint() je met un System.out.println("boucle ou boucle pas") et bas le resultat est que la phrase s'affiche infiniment dans la console... c'est pour ca que je pensait qu'il s'agissait d'une boucle.

Enfin bon, je suis pas un pro de java mais j'aimerais comprendre comment ils ont foutu ce putain de renderer, car pour changer la couleur d'une ligne ou une cellule je ne vois pas pourquoi il faut creer des classes bizzaroides qu'on comprends meme pas ce qu'on met la dedans :(

Si le message s'affiche tout le temps c'est sûrement qu'il se passe quelque chose dans ton application qui force le rafraîchissement de la table. Les renderers ne sont pas indispensables pour changer la couleur mais servent à bien d'autres choses. Tu peux par exemple remplacer le contenu d'une cellule par un champ texte, ou un arbre. Les renderes ont également l'intérêt d'être très performants. Comme le dit la documentation, le même renderer est utilisé pour dessiner toutes les cellules. Cette approche permet, comme je l'ai dit précédemment, de modifier la table à ta guise sans être contraint par les propriétés prévues ou non par les concepteurs. Enfin, je travaille dans l'équipe qui développe Swing donc si tu as des remarques*à faire au sujet de notre API je serai ravi de les transmettre au reste de l'équipe.

Excuse moi, je ne voulais pas manquer de respect envers les developpeurs de SWING, rien que pour nous avoir epargner le vieux AWT, ils merittent notre totale reconnaissance ;)

Enfin bon, je trouve vraiement dommage que pour changer juste une couleur dans une ligne cela demande 24H de recheches sur le net et finalement on obtient un truc qui marche a moitie.

Ce qui est de plus incoherent avec le fait qu'il est en effet tres facile de changer la couleur de la case selectionne (grace a une seule methode) et qu'il ne soit pas de meme pour changer la couleur d'une autre case autre que celle selectionnee.

Bonne continuation a vous,

ValFajr.

Ne t'en fais pas, je n'ai pas mal pris le message, je t'invite sincèrement à faire part de ton expérience. Je comprends ton problème vis-à-vis de la JTable mais dès que tu auras utilisé Swing un peu plus tu devrais comprendre pourquoi c'est fait ainsi. Des simplifications sont quand même disponibles, par exemple avec les highlighters de la JXTable du projet SwingX (swingx.dev.java.net). Ces highlighters devraient se trouver dans Java SE 6 également.

No probleme, pour etre franc je comprends jusqu'un certain point pourquoi la JTable fonctionne ainsi. C'est vraiement cool de pouvoir inclure des composants SWING tels que des JButton, JList et voire meme des JProgressBar dans une JTable. Le renderer est la pour pouvoir controler tout ce beau monde dans la JTable.

Enfin l'important c'est que j'ai reussie a resoudre le probleme en deplacant le repaint() ailleurs que dans la classe TableCelleRenderer.

Tout fonctionne normalement ;)
Merci a vous,

++
ValFair.