Discussion :

[zuzuu]

Bonjour,

J'utilise une JTable avec mon renderer pour les cellules et j'ai un petit soucis pour donner à ce renderer un type d'object défini. En effet, il ne prend que des chaines pour l'instant.

Voici un peu plus de détail :

Code :

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

1
2
3
4
5
 
T[5][5] data;
MyTableModel tableModel = new MyTableModel(data, ...;
JTable table = new JTable(tableModel);
table.setDefaultRenderer(Object.class, renderer);

J'utilise une JTable avec un model dans lequel j'ai un tableau de données d'un type T.
Mon renderer est un objet d'une classe qui étend DefaultTableCellRenderer pour le rendu de mes cellules.
Hors mon probleme est que dans la fonction "getTableCellRendererComponent(JTable jtable, Object obj, boolean flag, boolean flag1, int i, int j) {" le paramètre obj est toujours une chaine(String).
J'ai essayé de mettre :

Code :

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

1
2
3
4
5
T[5][5] data;
MyTableModel tableModel = new MyTableModel(data, ...;
JTable table = new JTable(tableModel);
table.setDefaultRenderer(T.class, renderer);

Mais dans ce dernier cas, ma fonction getTableCellRendererComponent() n'est pas plus appelée.

Savez vous comment faire pour passer mon object de type T ?

[visiwi]

Salut,

Il me semble (car je dit cela de mémoire) que cela vient de ta classe MyTableModel qui doit étendre un AbstractTableModel. Cette classe doit implémenter une méthode qui doit s'appeler getClolumnClass(int i) ou quelque chose d'approchant. Cette méthode doit retourner le bon type pour le colonne passée en argument, sinon par défaut c'est du String.

[zuzuu]

Mon modèle étends déjà cette classe.
Par contre, je vois ce que tu veux dire pour getColumnName(). Mais le truc, c'est que il y a des objets de type différents dans mon tableau.
Car en fait, j'avais besoin d'un header en colone, un en ligne et un dans le coin de la table en haut à gauche.
Donc, j'ai des données de type T et des données de type String. Et getColumnName(), fonctionne par colonne...

En gros, j'ai :

Code :

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

1
2
3
4
5
 
coin    String | col 1 String | col2 String | ....
ligne 1 String | data T type | data T type| ....
ligne 2 String | data T type | data T type| ....
...

[visiwi]

Mon modèle étends déjà cette classe.

Bien sûr. Ma remarque portait en fait sur la méthode.

Car en fait, j'avais besoin d'un header en colone, un en ligne et un dans le coin de la table en haut à gauche.
Donc, j'ai des données de type T et des données de type String.

Oui mais les données de la JTable (autre que le header) sont de même type pour une colonne donné, non ? Si oui, alors pas de problème, car getColumnClass ne s''occuppe pas du header, du moins je le crois.

[bouye]

Plutot que de chercher sans arret a bidouiller le modele pour indiquer les bonnes classes* pour les valeurs histoire d'avoir les bon renderer/editor ou de specifier les renderer/editor manuellement pour chaque colonne, je me suis tourne vers une solution dans laquelle on fourni un seul et unique renderer (resp pour un editor) capable d'utiliser un renderer delege et qui accepte qu'on en rajoute d'autres histoire d'etendre ses capacites.

*Ce qui est plutot penible et puis ne fonctionne pas de toute maniere quand la table contient des donnees heterogenes.

Note : c'est toujours en phase de test et est sujet a corrections et ajouts. Par exemple dans l'editor il me faut faire un adapteur pour propager les evenements avec la bonne source plutot que d'enregistrer directement le listener sur l'editor delege.

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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
 
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package org.spc.ofp.gui;
 
import java.awt.BasicStroke;
import java.awt.Component;
import java.awt.Paint;
import java.util.HashMap;
import java.util.Map;
import javax.swing.DefaultListCellRenderer;
import javax.swing.JList;
import javax.swing.JTable;
import javax.swing.JTree;
import javax.swing.ListCellRenderer;
import javax.swing.table.DefaultTableCellRenderer;
import javax.swing.table.TableCellRenderer;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeCellRenderer;
import javax.swing.tree.TreeCellRenderer;
import org.spc.ofp.graphics.gui.BasicStrokeCellRenderer;
import org.spc.ofp.graphics.gui.PaintCellRenderer;
 
/**
 *
 * @author fabriceb
 */
public abstract class MultiCellRenderer {
 
  /** Storage map.
   */
  private Map<Class<?>, Object> classRendererMap = new HashMap<Class<?>, Object>();
 
  /**
   * Register a renderer for a given type.
   * @param type The type.
   * @param renderer The renderer associated to this type.
   */
  protected void register(Class<?> type, Object renderer) {
    classRendererMap.put(type, renderer);
  }
 
  /**
   * Unregister a renderer for a given type.
   * @param type The type.
   */
  protected void unregister(Class<?> type) {
    classRendererMap.remove(type);
 
  }
 
  /** Gets a renderer for a given type.
   * @param type The type.
   * @return An <code>Object</code> instance or <code>null</code> is no renderer registered to this type.
   */
  protected Object getRenderer(Class<?> type) {
    return classRendererMap.get(type);
  }
 
  /** Searh renderer for given value.
   * @param value The value.
   * @return An <code>Object</code> instance or <code>null</code> is no renderer registered to this value's type.
   * If this value is <code>null</code>, defaults to the renderer for the <code>Object</code> class.
   */
  protected Object searchRenderer(Object value) {
    Object result = null;
    if (value != null) {
      Class<?> type = value.getClass();
      result = getRenderer(type);
      // Search super-classes.
      if (result == null) {
        for (Class<?> parent = type.getSuperclass(); (parent != null && parent != Object.class); parent = parent.getSuperclass()) {
          result = getRenderer(parent);
          if (result != null) {
            break;
          }
        }
      }
      // Search implemented interfaces.
      if (result == null) {
        Class<?>[] parents = type.getInterfaces();
        for (Class<?> parent : parents) {
          result = getRenderer(parent);
          if (result != null) {
            break;
          }
        }
      }
    }
    // Use default renderer instead.
    if (result == null) {
      result = getRenderer(Object.class);
    }
    return result;
  }
 
  public static class List extends MultiCellRenderer implements ListCellRenderer {
 
    public List() {
      registerRenderer(Paint.class, new PaintCellRenderer.List());
      registerRenderer(BasicStroke.class, new BasicStrokeCellRenderer.List());
      registerRenderer(Object.class, new DefaultListCellRenderer());
    }
 
    public void registerRenderer(Class<?> type, ListCellRenderer renderer) {
      register(type, renderer);
    }
 
    public void unregisterRenderer(Class<?> type) {
      unregister(type);
    }
 
    @Override
    public Component getListCellRendererComponent(JList list, Object value, int index, boolean isSelected, boolean cellHasFocus) {
      ListCellRenderer renderer = (ListCellRenderer) searchRenderer(value);
      return renderer.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);
    }
  }
 
  public static class Tree extends MultiCellRenderer implements TreeCellRenderer {
 
    public Tree() {
      registerRenderer(Paint.class, new PaintCellRenderer.Tree());
      registerRenderer(BasicStroke.class, new BasicStrokeCellRenderer.Tree());
      registerRenderer(Object.class, new DefaultTreeCellRenderer());
    }
 
    public void registerRenderer(Class<?> type, TreeCellRenderer renderer) {
      register(type, renderer);
    }
 
    public void unregisterRenderer(Class<?> type) {
      unregister(type);
    }
 
    @Override
    public Component getTreeCellRendererComponent(JTree tree, Object value, boolean selected, boolean expanded, boolean leaf, int row, boolean hasFocus) {
      if (value instanceof DefaultMutableTreeNode) {
        value = ((DefaultMutableTreeNode) value).getUserObject();
      }
      TreeCellRenderer renderer = (TreeCellRenderer) searchRenderer(value);
      return renderer.getTreeCellRendererComponent(tree, value, selected, expanded, leaf, row, hasFocus);
    }
  }
 
  public static class Table extends MultiCellRenderer implements TableCellRenderer {
 
    public Table() {
      registerRenderer(Paint.class, new PaintCellRenderer.Table());
      registerRenderer(BasicStroke.class, new BasicStrokeCellRenderer.Table());
      registerRenderer(Object.class, new DefaultTableCellRenderer());
    }
 
    public void registerRenderer(Class<?> type, TableCellRenderer renderer) {
      register(type, renderer);
    }
 
    public void unregisterRenderer(Class<?> type) {
      unregister(type);
    }
 
    @Override
    public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
      TableCellRenderer renderer = (TableCellRenderer) searchRenderer(value);
      return renderer.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
    }
  }
}

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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
 
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package org.spc.ofp.gui;
 
import java.awt.Color;
import java.awt.Component;
import java.util.EventObject;
import java.util.HashMap;
import java.util.Map;
import javax.swing.CellEditor;
import javax.swing.DefaultCellEditor;
import javax.swing.JCheckBox;
import javax.swing.JTable;
import javax.swing.JTextField;
import javax.swing.event.CellEditorListener;
import javax.swing.table.TableCellEditor;
import org.spc.ofp.graphics.gui.ColorCellEditor;
 
/**
 *
 * @author fabriceb
 */
public abstract class MultiCellEditor {
 
  /** Storage map.
   */
  private Map<Class<?>, CellEditor> classRendererMap = new HashMap<Class<?>, CellEditor>();
 
  /**
   * Register a renderer for a given type.
   * @param type The type.
   * @param renderer The renderer associated to this type.
   */
  protected void register(Class<?> type, CellEditor renderer) {
    classRendererMap.put(type, renderer);
  }
 
  /**
   * Unregister a renderer for a given type.
   * @param type The type.
   */
  protected void unregister(Class<?> type) {
    classRendererMap.remove(type);
 
  }
 
  /** Gets a renderer for a given type.
   * @param type The type.
   * @return A <code>CellEditor</code> instance or <code>null</code> is no renderer registered to this type.
   */
  protected CellEditor getRenderer(Class<?> type) {
    return classRendererMap.get(type);
  }
 
  /** Searh renderer for given value.
   * @param value The value.
   * @return A <code>CellEditor</code> instance or <code>null</code> is no renderer registered to this value's type.
   * If this value is <code>null</code>, defaults to the renderer for the <code>Object</code> class.
   */
  protected CellEditor searchRenderer(Object value) {
    CellEditor result = null;
    if (value != null) {
      Class<?> type = value.getClass();
      result = getRenderer(type);
      // Search super-classes.
      if (result == null) {
        for (Class<?> parent = type.getSuperclass(); (parent != null && parent != Object.class); parent = parent.getSuperclass()) {
          result = getRenderer(parent);
          if (result != null) {
            break;
          }
        }
      }
      // Search implemented interfaces.
      if (result == null) {
        Class<?>[] parents = type.getInterfaces();
        for (Class<?> parent : parents) {
          result = getRenderer(parent);
          if (result != null) {
            break;
          }
        }
      }
    }
    // Use default renderer instead.
    if (result == null) {
      result = getRenderer(Object.class);
    }
    return result;
  }
 
  public static class List {
  }
 
  public static class Tree {
  }
 
  public static class Table extends MultiCellEditor implements TableCellEditor {
 
    private TableCellEditor delegated;
 
    public Table() {
      registerRenderer(Color.class, new ColorCellEditor());
      registerRenderer(Enum.class, new EnumCellEditor());
      registerRenderer(Boolean.class, new DefaultCellEditor(new JCheckBox()));
      registerRenderer(Object.class, new DefaultCellEditor(new JTextField()));
    }
 
    public void registerRenderer(Class<?> type, TableCellEditor renderer) {
      register(type, renderer);
    }
 
    public void unregisterRenderer(Class<?> type) {
      unregister(type);
    }
 
    @Override
    public Component getTableCellEditorComponent(JTable table, Object value, boolean isSelected, int row, int column) {
      delegated = (TableCellEditor) searchRenderer(value);
      return delegated.getTableCellEditorComponent(table, value, isSelected, row, column);
    }
 
    @Override
    public Object getCellEditorValue() {
      return delegated.getCellEditorValue();
    }
 
    @Override
    public boolean isCellEditable(EventObject anEvent) {
      //return delegated.isCellEditable(anEvent);
      return true;
    }
 
    @Override
    public boolean shouldSelectCell(EventObject anEvent) {
      return delegated.shouldSelectCell(anEvent);
    }
 
    @Override
    public boolean stopCellEditing() {
      return delegated.stopCellEditing();
    }
 
    @Override
    public void cancelCellEditing() {
      delegated.cancelCellEditing();
    }
 
    @Override
    public void addCellEditorListener(CellEditorListener l) {
      delegated.addCellEditorListener(l);
    }
 
    @Override
    public void removeCellEditorListener(CellEditorListener l) {
      delegated.removeCellEditorListener(l);
    }
  }
}

[zuzuu]

Merci, je vais regarder cette solution.
En fait, dans mon cas, c'est juste que ma premiere colonne et ma premiere ligne doivent contenir des titres. Le reste de mes cases est de même type T.