JComboBox : Changer la couleur d'un élément ?

Version imprimable

Bonjour,

J'ai créer une comboBox qui contient des objets <Produit>.

Ma classe Produit contient 2 attributs :
- un string nom
- un string dangerosite

Je voudrais lors de la construction de ma comboBox, colorier les éléments "dangereux" en rouge.

Voici mon code :

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
 
	public JComboBox<Produit> getComboBoxProduits() {
		if (comboBoxProduits == null) {
			comboBoxProduits = new JComboBox<Produit>();
			comboBoxProduits.setPreferredSize(new Dimension(278, 23));
			comboBoxProduits.setMinimumSize(new Dimension(278, 23));
 
			try
			{
				// On récupère tous les noms de produits présents dans la BDD
				listeProduits = Requete4.listerProduits(bdd);
			} 
			catch (SQLException e)
			{
				System.out.println("Sql Erreur : " + e.getMessage());
			}
 
			if (listeProduits != null)
			{
				comboBoxProduits.setModel(new ModeleComboBoxProduits(listeProduits));
				comboBoxProduits.setSelectedIndex(-1);			
				comboBoxProduits.setRenderer(new MyCellRenderer());
 
			}
		}
		return comboBoxProduits;
	}
 
	/**
         * Modèle de la comboBox comboBoxProduit
         */
	class ModeleComboBoxProduits extends DefaultComboBoxModel<Produit>{
		private static final long serialVersionUID = -5812040723015922852L;
		private Vector<Produit> listeProduits;
 
		/**
                 * Création du modèle
                 * 
                 * @param listeOp la liste des produits
                 */
		public ModeleComboBoxProduits(Vector<Produit> listeProduits)
		{
			super();
			this.listeProduits = listeProduits;
		}
 
		@Override
		public int getSize()
		{
			return listeProduits.size();
		}
 
		@Override
		public Produit getElementAt(int index)
		{
			return listeProduits.get(index);
		}
 
		@Override
		public int getIndexOf(Object element)
		{
			return listeProduits.indexOf(element);
		}	
	}
 
	class MyCellRenderer extends DefaultListCellRenderer{
 
		private static final long serialVersionUID = 2937187796573906670L;
 
		/* (non-Javadoc)
		 * @see javax.swing.ListCellRenderer#getListCellRendererComponent(javax.swing.JList, java.lang.Object, int, boolean, boolean)
		 */
		@Override
		public Component getListCellRendererComponent(JList list, Object value,
				int index, boolean isSelected, boolean cellHasFocus)
		{
			MyCellRenderer c = (MyCellRenderer) (super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus));
 
 
			for (int i = 0 ; i < listeProduits.size(); i++)
			{
				if (! listeProduits.get(i).getDangerosite().equals(""))
				{
					if (index == i)
					{		
						c.setForeground(Color.RED);	
					}
				}
			}
 
			return c;
 
		}
	}

Ce code fonctionne mais lorsque je sélectionne un produit dangereux dans ma comboBox, la comboBox se referme et affiche alors l'élément sélectionné en noir.
Comment faire pour conserver ma couleur rouge ?

De plus, ici :

Code:

1
2
3
4
 
@Override
		public Component getListCellRendererComponent(JList list, Object value,
				int index, boolean isSelected, boolean cellHasFocus)

JList est de type brut et doit donc être paramétré de cette façon JList<E>.
Par quoi dois-je remplacer E ?

J'ai fouillé dans la doc et j'ai trouvé ceci :

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
 
Color background;
         Color foreground;
 
         // check if this cell represents the current DnD drop location
         JList.DropLocation dropLocation = list.getDropLocation();
         if (dropLocation != null
                 && !dropLocation.isInsert()
                 && dropLocation.getIndex() == index) {
 
             background = Color.BLUE;
             foreground = Color.WHITE;
 
         // check if this cell is selected
         } else if (isSelected) {
             background = Color.RED;
             foreground = Color.WHITE;
 
         // unselected, and not the DnD drop location
         } else {
             background = Color.WHITE;
             foreground = Color.BLACK;
         };
 
         setBackground(background);
         setForeground(foreground);

Mais aucune de ces conditions ne correspondent au moment où la liste se referme, après qu'on ai sélectionné un élément.
Rien à faire, l'élément retrouve alors sa couleur d'origine (chez moi, il est écrit en noir sur un fond bleu).

Quelqu'un pourrait me dire comment conserver mon élément en rouge ?

20/06/2014, 08h37
joel.drigo

Salut,

La valeur affichée, lorsque la JCombo est "fermée", l'est par un éditeur (sauf si la combo n'est pas éditable), qui n'est pas concerné par le ListCellRenderer. Ecris ton propre ComboBoxEditor, en étendant BasicComboBoxEditor : en modifiant la méthode setItem, pour qu'elle change le foreground en plus de changer la valeur affichée dans le JTextField, en fonction de tes condition.
20/06/2014, 11h31
wam111

Bonjour,

Merci pour ta réponse.

Cependant, je n'arrive pas à utiliser mon propre comboBoxEditor, que ce soit en étendant BasicComboEditor ou en implémentant ComboBoxEditor (la méthode setItem() n'est jamais activée).

Pourrait-tu me mettre une exemple pour que je puisse comprendre comment cela fonctionne ?

Oui, effectivement, c'est un peu plus complexe que semblait l'indiquer la théorie (la documentation en fait).

Voici une solution que fonctionne dans les 2 cas (seule contrainte, les couleurs de la combo ne doivent pas changer après initialisation).

Pour l'exemple, tout d'abord, j'ai fait une classe pour représenter mon objet à représenter :

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
public class MyObject {
 
	public enum DangerLevel {
 
		NONE, LOW, HIGH;
 
	}
 
	public static final Color HIGH_DANGER_COLOR = Color.RED;
 
	public static final Color LOW_DANGER_COLOR = Color.ORANGE;
 
	private final String name;
	private final DangerLevel dangerLevel;
 
	/**
         * 
         */
	public MyObject(String name, DangerLevel dangerLevel) {
		if (name == null || dangerLevel == null) {
			throw new IllegalArgumentException();
		}
		this.name = name;
		this.dangerLevel = dangerLevel;
	}
 
	public final String getName() {
		return name;
	}
 
	public final DangerLevel getDangerLevel() {
		return dangerLevel;
	}
 
	@Override
	public String toString() {
		return name;
	}
 
        /**
          * Cette méthode sert à colorer un item
          */
	public static void setColors(MyObject myObject, 
									 Component component,
									 Color defaultForeground,
									 Color defaultBackground) {
		switch (myObject.getDangerLevel()) {
		case LOW:
			component.setForeground(MyObject.LOW_DANGER_COLOR);
			if ( defaultBackground!=null) {
				component.setBackground(defaultBackground);
			}
			break;
		case HIGH:
			component.setForeground(MyObject.HIGH_DANGER_COLOR);
			if ( defaultBackground!=null) {
				component.setBackground(defaultBackground);
			}
			break;
		default:
			if ( defaultForeground!=null) {
				component.setForeground(defaultForeground);
			}
			if ( defaultBackground!=null) {
				component.setBackground(defaultBackground);
			}
			break;
		}
	} 
 
}

Voici le code du ListCellRenderer :

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
public class MyObjectComboRenderer extends DefaultListCellRenderer {
 
	private static final long serialVersionUID = 1L;
 
	private boolean allowColorSet;
 
	private Color defaultForeground;
 
	private Color defaultBackground;
 
	/**
         * 
         */
	public MyObjectComboRenderer(JComboBox<MyObject> combo) {
		if ( combo.isEditable() ) {
			ComboBoxEditor editor = combo.getEditor();
			this.defaultForeground=editor.getEditorComponent().getForeground();
			this.defaultBackground=editor.getEditorComponent().getBackground();
		}
	}
 
	@Override
	public void setForeground(Color fg) {
		if ( allowColorSet ) {
			super.setForeground(fg);
		}
	}
 
	@Override
	public void setBackground(Color fg) {
		if ( allowColorSet ) {
			super.setBackground(fg);
		}
	} 
 
 
	 public Component getListCellRendererComponent(
		        JList<?> list,
		        Object value,
		        int index,
		        boolean isSelected,
		        boolean cellHasFocus) {
 
		 allowColorSet = true;
		 try {
			 Component component = super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);
 
			 if ( value instanceof MyObject ) { 
				 MyObject.setColors((MyObject) value, component, defaultForeground==null?list.getForeground():defaultForeground, defaultBackground==null?list.getBackground():defaultBackground);
			 }
			 return component;
 
		 }
		 finally {
			 allowColorSet = false;
		 }
 
    }
 
}

Voici le code de l'éditeur :

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
public class MyObjectComboEditor implements ComboBoxEditor { 
 
	private final ComboBoxEditor editor;
	private final Color defaultForeground;
	private final Color defaultBackground;
 
	public MyObjectComboEditor(JComboBox<MyObject> combo) { 
		this.editor = combo.getEditor();
		this.defaultForeground=this.editor.getEditorComponent().getForeground();
		this.defaultBackground=this.editor.getEditorComponent().getBackground();
	}
 
 
	@Override
	public void setItem(Object anObject) {
		editor.setItem(anObject);
		if ( anObject instanceof MyObject ) {
			MyObject.setColors((MyObject) anObject, getEditorComponent(), defaultForeground, defaultBackground);
		}
	}
 
	@Override
	public Component getEditorComponent() {
		return editor.getEditorComponent();
	}
 
	@Override
	public Object getItem() {
		return editor.getItem();
	}
 
	@Override
	public void selectAll() {
		editor.selectAll();
	}
 
	@Override
	public void addActionListener(ActionListener l) {
		editor.addActionListener(l);
	}
 
 
	@Override
	public void removeActionListener(ActionListener l) {
		editor.removeActionListener(l);
	} 
 
}

Et voici le code de mise en application, pour les 2 cas (éditable ou non) :

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
public class Test {
 
	public static void main(String[] args) {
 
		JFrame frame = new JFrame("Demo JCombo avec couleurs");
 
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
		frame.getContentPane().add(createPanel());
 
		frame.setLocationRelativeTo(null);
		frame.pack();
 
		frame.setVisible(true);
 
	}
 
	private static Component createPanel() {
		JPanel panel = new JPanel();
		panel.setLayout(new GridLayout(0, 2));
		panel.add(new JLabel("Editable"));
		panel.add(createCombo(true));
		panel.add(new JLabel("Non editable"));
		panel.add(createCombo(false));
		return panel;
	}
 
	private static Component createCombo(boolean editable) {
		JComboBox<MyObject> combo = new JComboBox<>(createData());
		if ( editable ) {
			combo.setEditable(true);
			combo.setEditor(new MyObjectComboEditor(combo));
		}
		combo.setRenderer(new MyObjectComboRenderer(combo));
		return combo;
	}
 
	private static Vector<MyObject> createData() {
		final Random random = new Random();
		final int n = 5 + random.nextInt(10);
		final Vector<MyObject> data = new Vector<>(n);
		final DangerLevel[] dangerLevels = MyObject.DangerLevel.values();
		// garanti qu'on a 1 item de chaque type
		for( DangerLevel dangerLevel : dangerLevels ) {
			data.add(new MyObject("Truc DANGER=" + dangerLevel, dangerLevel));
		}
		// création de données aléatoires pour remplir...
		for(int i=dangerLevels.length; i<n; i++) {
			MyObject.DangerLevel dangerLevel = dangerLevels[random.nextInt(dangerLevels.length)];
			String name = "Truc " + i + " (DANGER="+dangerLevel+")";
			data.add(new MyObject(name, dangerLevel));
		}
		return data;
	}
 
}

23/06/2014, 11h14
wam111

Ça fonctionne parfaitement x)

Un grand merci pour ton aide ;)

Je relance le sujet car j'ai un problème :
Désormais, la comboBox est éditable : l'utilisateur peut donc écrire dedans.
Or, je voudrais la remettre non éditable, comme ceci :

Code:

1
2
 
comboBox.setEditable(false);

Le problème, c'est qu'alors je ne peux plus colorier mes éléments en rouge...

Comment dois-je faire ?

Voici ma classe Produit :

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
 
public class Produit
{
	String nom;
	String dangerosite;
 
	/**
         * @return nom
         */
	public String getNom()
	{
		return nom;
	}
	/**
         * @param nom à définir
         */
	public void setNom(String nom)
	{
		this.nom = nom;
	}
	/**
         * @return dangerosite
         */
	public String getDangerosite()
	{
		return dangerosite;
	}
	/**
         * @param dangerosite à définir
         */
	public void setDangerosite(String dangerosite)
	{
		this.dangerosite = dangerosite;
	}
	/* (non-Javadoc)
	 * @see java.lang.Object#toString()
	 */
	@Override
	public String toString()
	{
		return nom; // On affiche que le nom dans les comboBox
	}
 
	/**
     * Cette méthode sert à colorer un produit de la comboBox comboBoxProduits
     */
	public static void setColors(Produit produit, Component component) 
	{
		if (! produit.getDangerosite().equals(""))
		{	
				component.setForeground(Color.RED);	
		}
		else
			component.setForeground(Color.BLACK);	
	} 
}

Voici ma comboBox :

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
 
         public JComboBox<Produit> getComboBoxProduits() {
		if (comboBoxProduits == null) {
			comboBoxProduits = new JComboBox<Produit>();
			comboBoxProduits.setPreferredSize(new Dimension(320, 23));
			comboBoxProduits.setMinimumSize(new Dimension(320, 23));
			bordureComboBox = comboBoxProduits.getBorder();
 
			try
			{
				// On récupère tous les noms de produits présents dans la BDD
				listeProduits = Requete.listerProduits(bdd);
			} 
			catch (SQLException e)
			{
				System.out.println("Sql Erreur : " + e.getMessage());
			}
 
			if (listeProduits != null)
			{
				comboBoxProduits.setModel(new ModeleComboBoxProduits(listeProduits));
				comboBoxProduits.setSelectedIndex(-1);		
 
				// On colore les produits dangereux en rouge
				comboBoxProduits.setEditable(true);
				comboBoxProduits.setEditor(new ComboBoxProduitsEditor(comboBoxProduits));					
				comboBoxProduits.setRenderer(new CellRendererComboBoxProduits());
			}		
 
			comboBoxProduits.addActionListener(new ActionListener()
			{
				public void actionPerformed(ActionEvent event)
				{
					// On supprime la bordure rouge en cas d'erreur
					lblErreur.setText("");
					comboBoxProduits.setBorder(bordureComboBox);	
				}
			});
		}	
		return comboBoxProduits;
	}

Voici mon Renderer :

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
 
         /**
         * Affichage des couleurs des éléments de la comboBox comboBoxProduit lors de l'ouverture de la comboBox
         */
	public class CellRendererComboBoxProduits extends DefaultListCellRenderer 
	{		 
		private static final long serialVersionUID = -7798638646628095008L; 
 
		public Component getListCellRendererComponent(
			        JList<?> list,
			        Object value,
			        int index,
			        boolean isSelected,
			        boolean cellHasFocus) 
		{	
			 Component component = super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);
 
			 if ( value instanceof Produit ) 
			 { 
				// On colore les éléments de la comboBox lors de l'ouverture de la comboBox
				 Produit.setColors((Produit) value, component);
			 }
 
			 return component; 
	     }
	}

Et voici mon Editor :

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
 
         /**
         * Affichage des couleurs des éléments de la comboBox comboBoxProduit lorsque la comboBox est fermée
         */
	public class ComboBoxProduitsEditor implements ComboBoxEditor 
	{ 		 
		private final ComboBoxEditor editor;
 
		public ComboBoxProduitsEditor(JComboBox<Produit> combo) 
		{ 
			this.editor = combo.getEditor();
			// On affiche le background par défaut de la comboBox
			editor.getEditorComponent().setBackground(comboBoxProduits.getBackground());
		} 
 
		@Override
		public void setItem(Object anObject) 
		{
			editor.setItem(anObject);
			if ( anObject instanceof Produit ) 
			{
				// On colore les éléments de la comboBox lorsqu'elle est fermée
				Produit.setColors((Produit) anObject, getEditorComponent());
			}
		}
 
		@Override
		public Component getEditorComponent() 
		{
			return editor.getEditorComponent();
		}
 
		@Override
		public Object getItem() 
		{
			return editor.getItem();
		}
 
		@Override
		public void selectAll() 
		{
			editor.selectAll();
		}
 
		@Override
		public void addActionListener(ActionListener l) 
		{
			editor.addActionListener(l);
		}
 
 
		@Override
		public void removeActionListener(ActionListener l) 
		{
			editor.removeActionListener(l);
		} 	 
	}

24/06/2014, 10h19
joel.drigo

Regardes le code que je t'ai donné : tout est dans le flag allowColorSet. La documentation dit que lorsque le JComboBox n'est pas éditable, c'est le ListCellRenderer, prévu pour faire le rendu des items dans la popup, qui est utilisé pour faire le rendu de la partie "sélection". Si on regardes le code, c'est effectivement le cas, mais juste après, le foreground et le background sont forcés avec ceux de la JComboBox, qui remplacent celles du renderer. Le flag permet de l'éviter.
24/06/2014, 11h26
wam111

Ça fonctionne !

Merci ;)