Discussion :

[ythim]

Bonjour à tous, je me penche sur un petit problème depuis ce matin j'ai quelques soucis pour le résoudre.

Je m'explique, je cherche à créé une JTable assez particuliere: cette JTable doit contenir 3 colonne, la premiere toute bete contenant du texte, pas de souci, la deuxieme par contre doit contenir une combobox avec a l'intérieur une liste de couleur. La 3eme doit contenir un boutton ( je ne m'en suis pas encore occupé)

Vous l'aurez compris, mon problème réside dans la représentation de la comboBox. Je suis parvenue jusque la à mettre ma comboBox colorée dans ma jtable mais il y a des problème lorsque je clique dessus pour faire défiler les couleurs.

Voici les différents code que j'ai utilisé:

Déclaration de ma JTable

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
colormodel = new ColorModel(tabEtatReservation);
jColorTable = new JTable(colormodel);
 
TableColumn c1 = jColorTable.getColumnModel().getColumn(1);
ComboBoxPanel cbp = new ComboBoxPanel();
c1.setCellRenderer(cbp);
c1.setCellEditor(new MyComboBoxEditor());
 
jColorTable.setCellSelectionEnabled(true);
jColorTable.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
jColorTable.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
TableColumn column = null;
TableRow row = null;
for (int i = 0; i < 3; i++) {
	column = jColorTable.getColumnModel().getColumn(i);
	column.setPreferredWidth(100);
	column.setMaxWidth(100); 
	column.setMinWidth(100); 
	column.setResizable(false);		    
}

Mon color model retourne un objet de type Color pour la colonne numero 1.


Classe ComboBoxPanel:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
import java.awt.Color;
import java.awt.Component;
import java.awt.FlowLayout;
import java.util.ArrayList;
 
import javax.swing.JComboBox;
import javax.swing.JLabel;
import javax.swing.JTable;
import javax.swing.table.TableCellRenderer;
 
import planning.Reservation;
 
/**
This renderer renders a color value as a panel with the
given color.
*/
class ComboBoxPanel implements TableCellRenderer
{  
	public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
        Color c = (Color)value;
 
        ArrayList colors = new ArrayList();
        colors.add(Color.BLUE);
        colors.add(Color.BLACK);
        colors.add(Color.WHITE);
        colors.add(Color.RED);
        colors.add(Color.PINK);
 
        MyComboBoxModel colorsNeeded = new MyComboBoxModel(colors);
        JComboBox myComboBox = new JComboBox(colorsNeeded);
        myComboBox.setRenderer(new MyComboBoxRenderer());
 
        if(isSelected == true){
        	myComboBox.setSelectedItem(c);
        }
 
        return myComboBox;
    }
 
}

Classe MyComboBoxEditor:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
import java.awt.Color;
import java.awt.Component;
import java.awt.event.MouseEvent;
import java.util.ArrayList;
import java.util.EventObject;
 
import javax.swing.AbstractCellEditor;
import javax.swing.JComboBox;
import javax.swing.JComponent;
import javax.swing.JTable;
import javax.swing.JTextField;
import javax.swing.table.TableCellEditor;
 
 
	public class MyComboBoxEditor extends AbstractCellEditor implements TableCellEditor {
 
 
		/**
                 * Composant retourné par la fonction getTableCellEditorComponent(..)
                 */
		private JComponent component;
 
 
		/**
                 * Nombre de clique à effectuer à la souris pour déclencher l'édition, et donc l'utilisation
                 * du composant <code>component</code>.
                 */
		private int clickCountToStart = 1;
 
 
 
		  public MyComboBoxEditor() {
		   // Vide	   
		  }
 
		  /** {@inheritDoc}
                   */
		public Component getTableCellEditorComponent(JTable table, Object value, boolean isSelected, int row, int column) {
 
 
 
			ArrayList colors = new ArrayList();
	        colors.add(Color.BLUE);
	        colors.add(Color.BLACK);
	        colors.add(Color.WHITE);
	        colors.add(Color.RED);
	        colors.add(Color.PINK);
 
	        MyComboBoxModel colorsNeeded = new MyComboBoxModel(colors);
	        JComboBox myComboBox = new JComboBox(colorsNeeded);
	        myComboBox.setRenderer(new MyComboBoxRenderer());
 
	        this.component = myComboBox;
		    return this.component;
 
		  }
 
 
 
		public Object getCellEditorValue() {
			return this.component;
		}
 
 
		/**
                 * Pour gérer le nb de clique nécessaire à l'edition
                 */
		public boolean isCellEditable(EventObject anEvent) {
			if (anEvent instanceof MouseEvent) { 
				return ((MouseEvent)anEvent).getClickCount() >= clickCountToStart;
			}
			return true;
		}
 
 
		/**
                 * Retourne le nombre de clique nécessaire à l'édition de la cellule.
                 * 
                 * @return Retourne le nombre de clique nécessaire à l'édition de la cellule
                 */ 
		public int getClickCountToStart() {
			return clickCountToStart;
		}
 
 
		/**
                 * Affecte le nombre de clique nécessaire à l'édition de la cellule.
                 *  
                 * @param clickCountToStart nombre de clique
                 */
		public void setClickCountToStart(int clickCountToStart) {
			this.clickCountToStart = clickCountToStart;
		}
 
 
 
}

J'utilise les 2 classe MyComboBoxModel & MyComboBoxRenderer fortement inspiré de ce forum :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
import javax.swing.ComboBoxModel;
import javax.swing.event.ListDataListener;
import java.util.ArrayList;
import java.awt.Color;
 
/**
 * Created by IntelliJ IDEA.
 * User: bebe
 * Date: Jun 1, 2006
 * Time: 6:59:05 PM
 * To change this template use File | Settings | File Templates.
 */
public class MyComboBoxModel implements ComboBoxModel {
 
    /*
       My model.
       Really, think about a model as the data your combobox should contain. how these data should be displayed visually doesn't matter for the moment.
    */
    private ArrayList colors = null;
 
    private Color selectedColor = null;
 
    /* You need to specify some colors in the constructor. */
    public MyComboBoxModel(ArrayList colors) {
        if (colors == null) {
            /*
               if you don't specify any color, you will be notified ;-)
            */
            throw new IllegalArgumentException("I need an arraylist of colors to make my job correctly.");
        }
        this.colors = colors;
    }
 
    /*  @see javadoc ComboBoxModel.
 
        This is a method called by an internal mechanism of Swing.
        When, why, how comes... The short version is Swing rocks and he knows
        when and how to do his job!
 
        Anyway, thanks to this methid you can keep a reference on the choosen item.
    */
    public void setSelectedItem(Object anItem) {
        this.selectedColor = (Color)anItem;
    }
 
    /*
        Also called by Swing.
        In the previous method, you kept a reference on the selected item.
        Now, when swing ask you wich item has been choosen, you tell him.
 
        @see javadoc ComboBoxModel.
    */
    public Object getSelectedItem() {
        return selectedColor;
    }
 
    /*
      Swing needs to know how many item you combobox contains, or if you
      prefer, how many Color exists in you model.
 
      @see javadoc ComboBoxModel.
    */
    public int getSize() {
        return colors.size();
    }
 
    /*
      Don't you think you need to tell Swing what are the datas ?
     @see javadoc ComboBoxModel.
    */
    public Object getElementAt(int index) {
        return colors.get(index);
    }
 
    /*
       These two next methods are imposed by ComboBoxModel
       We don't need them for what you need.
    */
    public void addListDataListener(ListDataListener l) {
        //To change body of implemented methods use File | Settings | File Templates.
    }
 
    public void removeListDataListener(ListDataListener l) {
        //To change body of implemented methods use File | Settings | File Templates.
    }
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
import javax.swing.JLabel;
import javax.swing.ListCellRenderer;
import javax.swing.JList;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.Color;
import java.awt.Graphics;
 
/**
 * Created by IntelliJ IDEA.
 * User: bebe
 * Date: Jun 1, 2006
 * Time: 7:01:53 PM
 * To change this template use File | Settings | File Templates.
 */
public class MyComboBoxRenderer extends JLabel implements ListCellRenderer {
 
    /* The background color that will be used to paint the label. */
    private Color backgroundColor = null;
 
    public MyComboBoxRenderer() {
        /*
          each color is rendered as a label.  [width = 200 and height = 50].
        */
        setPreferredSize(new Dimension(200, 50));
        setOpaque(true);
    }
 
    /*
       This is also a method called by Swing. Like in the model. When why... swing knows when ;-)
 
       For each value of you model, for each colors, swing asks :"you how should I display this item ?"
       And what you have to do is to answer his question returning him a whatever Component (jlabel, jPanel, jTextField...).
       here, you return this himself because I extended JLabel, but before doing that, you need to repaint
       the label using the selected color.
    */
    public Component getListCellRendererComponent(JList list, Object value, int index, boolean isSelected, boolean cellHasFocus) {
        if (value != null) {
            backgroundColor = (Color) value;
        } else {
            backgroundColor = null;
        }
 
        return this;
    }
 
    /* Paint the label with the selected color. */
    @Override
    public void paint(Graphics g) {
        setBackground(backgroundColor);
        super.paint(g);
    }
}

Je sais que ca fait beaucoup de code j'en suis désolé, mais le souci viens je pense de la gestion de l'editor pour ma combobox.

J'avoue que je ne suis pas très callé en JTable, si jamais vous avez une quelconque idée concernant mon problème n'hesitez pas.

Merci pour votre aide.

[ythim]

Je me permet d'ajouter encore une petite question... Savez vous comment il est possible de récupéré mes évenements sur ma ComboBox?

Je sais pas si je m'exprime tres bien, mai j'aimerai savoir quand un utilisateur modifie la valeur dans la comboBox coloré et quelle choix il fait ...

[adiGuba]

Salut,


Quel est le problème exactement ? Tu en parles beaucoups mais tu ne l'explique jamais...

Sinon on dirait que tu as mal compris le principe des Renderer et des Editor : il s'agit d'une classe qui s'occupera de l'affichage de tous les éléments du même type de la JTable.

Donc tu as besoin :

• D'un TableModel qui contiendra tes données.
• D'un Renderer qui affichera les couleurs.
• D'un Editor qui affichera la ComboBox de selection.

Enfin je te conseille vivement d'hériter des implémentations abstraites ou par défaut plutôt que d'implémenter directement l'interface (ex hériter de DefaultTableCellRenderer au lieu d'implémenter TableCellRenderer).

a++

[ythim]

J'avoue mélangé un peu tout et je te remerci de te pencher sur la question.

Pour expliquer un peu la chose, je veu traiter dans une JTable les élèments de mon application qui sont des état. Un état est caractérisé par un nom et un couleur.
Je veux permettre à l'utilisateur, grace a cette JTable, de pouvoir changé la couleur d'un état.


Pour cela j'ai donc dans mon tableau la premiere colonne qui liste les noms des etats et la 2eme qui liste les couleurs. La particularité de la 2eme colonne est qu'elle doit contenir une combobox pour permettre a l'utilisateur de changer la couleur. J'ai trouvé sur le forum le moyen de mettre des couleurs directement dans une combobox à la place du texte.

(J'espere que vous me suivez) J'avez donc pensé a faire apparaitre directement dans la combobox les couleurs possible pour l'utilisateur.

Voila en résumé mes objectifs. D'un point de vue réalisation j'ai fais quelque modif et je me rend compte que c'était très fouilli mes premiere explication.

Donc comme je vous l'ai dis j'ai ma JTable, je lui applique un modele qui contient un tableau d'état (nom,couleur).

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
package guiPlanning;
 
import java.awt.Color;
import java.util.ArrayList;
import java.util.GregorianCalendar;
 
import javax.swing.JButton;
import javax.swing.JComboBox;
import javax.swing.table.AbstractTableModel;
 
import planning.EtatReservation;
 
public class ColorModel extends AbstractTableModel {
 
	private ArrayList tabEtatReservation;
	private ArrayList colors = null;
 
 
	public ColorModel(ArrayList tabEtatReservation) {
		this.tabEtatReservation = tabEtatReservation;
	}
 
	public int getRowCount() {
		return tabEtatReservation.size();
	}
 
	public int getColumnCount() {
		return 3;
	}
 
	public Object getValueAt(int rowIndex, int columnIndex) {
		Object retour = null;
		final EtatReservation r = (EtatReservation)tabEtatReservation.get(rowIndex);
		if(columnIndex==0){
			retour = r.getNom_etat();
		}
		if(columnIndex==1){
 
			ArrayList colors = new ArrayList();
	        colors.add(Color.BLUE);
	        colors.add(Color.BLACK);
	        colors.add(Color.WHITE);
	        colors.add(Color.RED);
	        colors.add(Color.PINK);
	        colors.add(Color.YELLOW);
 
	        MyComboBoxModel colorsNeeded = new MyComboBoxModel(colors);
	        final JComboBox myComboBox = new JComboBox(colorsNeeded);
	        myComboBox.setRenderer(new MyComboBoxRenderer());
	        myComboBox.setSelectedItem(r.getColor_etat());
 
	        myComboBox.addItemListener(new java.awt.event.ItemListener() {
				public void itemStateChanged(java.awt.event.ItemEvent e) {
					Color c = (Color)myComboBox.getSelectedItem();
					r.setColor_etat(c);
					fireTableDataChanged();
					System.out.println(tabEtatReservation);
				}
			});
		    retour = myComboBox;
		}
		if(columnIndex==2){
			retour = "enregistrer";
		}
 
		return retour;
	}
 
	public String getColumnName(int column) {
		String retour = "";
		if(column==0){
			retour = "Etat";
		}
		if(column==1){
			retour = "Couleur";
		}
		if(column==2){
			retour = "Modifier";
		}
		return retour;
	}
 
	public boolean isCellEditable(int rowIndex, int columnIndex) {
	return true;
	}
 
	//public void setValueAt(Object aValue, int row, int column) { data[row][column] = aValue; }
 
	public ArrayList getTabPoste() {
		return this.tabEtatReservation;
	}
 
 
	public void setTabPoste(ArrayList tab) {
		this.tabEtatReservation = tab;
		fireTableDataChanged();
	}
 
 
	public Class getColumnClass(int c) {
		Class cl = null;
		if(c==0){
			cl = String.class;
		}
		if(c==1){
			cl = JComboBox.class;
		}
		if(c==2){
			cl = JButton.class;
		}		
		return cl;		
	}
 
	/* (non-Javadoc)
	 * @see javax.swing.table.AbstractTableModel#setValueAt(java.lang.Object, int, int)
	 */
 
}

La methode GetValueAt de mon modele me retourne ma ComboBox coloré. Jusque la tout va bien.

Le souci viendrai je pense de l'éditor. Et je ne pense pas tres bien cerné le fonctionnement de celui ci.

J'ai modifié la declaration de ma JTable, en indiquant pour ma colonne 1 (celle des couleurs) que j'appliqué un Editor par default, celui d'une ComboBox

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
TableColumn c1 = jColorTable.getColumnModel().getColumn(1);
			ComboBoxPanel cbp = new ComboBoxPanel();
			c1.setCellRenderer(cbp);
 
			ArrayList colors = new ArrayList();
	        colors.add(Color.BLUE);
	        colors.add(Color.BLACK);
	        colors.add(Color.WHITE);
	        colors.add(Color.RED);
	        colors.add(Color.PINK);
	        colors.add(Color.YELLOW);
 
	        MyComboBoxModel colorsNeeded = new MyComboBoxModel(colors);
	        JComboBox myComboBox = new JComboBox(colorsNeeded);
	        myComboBox.setRenderer(new MyComboBoxRenderer());
 
			c1.setCellEditor(new DefaultCellEditor(myComboBox));

En appliquant cet editor j'ai bien mes combobox qui fonctionne, je vois mes couleurs a l'intérieur de celle ci cependant lorsque j'en modifie une, le contenu des autres est également modifié.

En esperant avoir été un peu plus clair cette fois ci

Merci pour toutes vos réactions.

[ythim]

Donc tu as besoin :

• D'un TableModel qui contiendra tes données.
• D'un Renderer qui affichera les couleurs.
• D'un Editor qui affichera la ComboBox de selection.

• J'ai éffectivement mon Model avec les données sortie de ma BDD
• Mon renderer qui affiche mes données , j'en applique un spécialement pour la colonne qui traite les combobox.
• et comme je l'ai dis j'ai défini un editor. Mais je suis pas sur de sa déclaration.

[adiGuba]

Oui mais ce soit trois éléments bien distinct ! Or tu les mélanges un peu dans tous les sens...

Ton Model ne devrait se contenter que des données, et n'avoir aucune relation avec le Renderer ou l'Editor ni avec le type des composants qui seront chargée de les représentér...

De plus si les données de ton modèle doivent être modifié tu doit implémenter la méthode setValueAt(), ce qui donnera :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
class ColorModel extends AbstractTableModel {
 
    public Class getColumnClass(int columnIndex) {
        switch (columnIndex) {
        case 0: return String.class;
        case 1: return Color.class;
        case 2: return String.class;
        }
        return String.class;
    }
 
    public Object getValueAt(int rowIndex, int columnIndex) {
        final EtatReservation r = (EtatReservation)tabEtatReservation.get(rowIndex);
        switch (columnIndex) {
        case 0: return r.getNom_etat();
        case 1: return r.getColor_etat();
        case 2: return "enregistrer";
        }
        return null;
    }
 
    public void setValueAt(Object data, int rowIndex, int columnIndex) {
        final EtatReservation r = (EtatReservation)tabEtatReservation.get(rowIndex);
        switch (columnIndex) {
        case 0: r.setNom_etat((String)data);
        case 1: r.setColor_etat((Color)data);
        case 2: // TODO
        }
    }
 
    // + le reste de ton code
}

La méthode getColumnClass() doit renvoyer la classe de la données et non pas du composant qui l'affiche. Idem pour getValueAt() qui doit renvoyer la données et non pas le composant. Enfin setValueAt() est neccessaire pour mettre à jour la table...



Le Renderer est lui chargé d'afficher les couleurs, et pourrait se limiter à ceci dans ton cas :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
class ColorRenderer extends DefaultTableCellRenderer {
    @Override
    public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
        // On appelle la méthode parente qui se charge de l'initialisation
        // en lui passant "" afin de ne rien afficher :
        Component c = super.getTableCellRendererComponent(table, " ", isSelected, hasFocus, row, column);
        // On change la couleur de fond :
        c.setBackground((Color)value);
        // Et on retourne l'objet courant :
        return c;
    }
}

que tu appliques à ta table de la manière suivante :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

jColorTable.setDefaultRenderer(Color.class, new ColorRenderer());

Ainsi toutes les cellules qui contiennent un objet de type Color seront affiché avec ce Renderer...

Enfin il te faut également un Renderer pour la JCombo, sur le même principe :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
class ComboCellRenderer extends DefaultListCellRenderer {
 
    @Override
    public Component getListCellRendererComponent(JList list, Object value, int index, boolean isSelected, boolean cellHasFocus) {
        // On appelle la méthode parente qui se charge de l'initialisation
        // en lui passant "" afin de ne rien afficher :
        super.getListCellRendererComponent(list, " ", index, isSelected, cellHasFocus);
        // On change la couleur de fond :
        this.setBackground((Color)value);
        return this;
    }
}

Qui sera utilisé dans ton Editor :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
    JComboBox combo = new JComboBox( new Color[]{
                Color.RED, Color.BLUE, Color.YELLOW,
                Color.GREEN, Color.PINK } );
        combo.setRenderer(new ComboCellRenderer());    
        jColorTable.setDefaultEditor(Color.class, new DefaultCellEditor(combo));

Ce qui devrait être un peu mieux...
Maintenant il reste surement plein de petite corrections à faire pour améliorer l'affichage (comme par exemple en jouant avec les valeurs selected et hasFocus pour modifier l'apparence)

a++

[ythim]

Effectivement j'avais un peu trop mélangé les renderers, les models et les editors. Merci pour cette reponse compléte...

J'ai bien défini la méthode SetValueAt mais j'ai encore une question

Pour pouvoir agir sur les données de mon model il faut que je face appel à cette méthode setValueAt je suis d'accord (ou tout autre methode qui appartient a mon model et qui modifie le contenue de celui ci). Ma question est de savoir ou dois je faire appel à cette methode???

Dans l'editor ? en ajoutant un actionlistener sur ma combobox?

Merci encore pour toute tes reponses

[adiGuba]

Ma question est de savoir ou dois je faire appel à cette methode???

Dans l'editor ? en ajoutant un actionlistener sur ma combobox?

C'est la JTable qui s'en occupe.

Grosso-modo cela fonctionne de la manière suivante : lorsque tu édites une cellule, la JTable appelle getColumnClass() de ton modèle pour connaitre le type de la cellule, et récupère l'Editor associé. Elle utilise ensuite la méthode getTableCellEditorComponent() de ce dernier afin de récupérer le composant chargé de l'edition (le JComboBox dans ce cas).
Une fois que l'édition est fini elle utilise la méthode getCellEditorValue() de l'Editor pour récupérer la valeur et appele ensuite setValueAt() de ton modèle...

a++