Colonne et sous colonne

Bonjour à tous,

J'ai récupéré un script qui permet d'afficher
des colonnes et des sous colonnes.

Classe ColumnGroup

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
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
 
package test;
 
import java.util.Enumeration;
import java.util.Vector;
 
import java.awt.Component;
import java.awt.Dimension;
import javax.swing.JLabel;
import javax.swing.JTable;
import javax.swing.UIManager;
import javax.swing.table.DefaultTableCellRenderer;
import javax.swing.table.JTableHeader;
import javax.swing.table.TableCellRenderer;
import javax.swing.table.TableColumn;
 
public class ColumnGroup
{
  protected TableCellRenderer renderer;
  protected Vector v;
  protected String text;
  protected int margin = 0;
 
  public ColumnGroup(String text) {
    this(null, text);
  }
 
 
  public ColumnGroup(TableCellRenderer renderer, String text)
  {
    if (renderer == null) {
      this.renderer = new DefaultTableCellRenderer() {
        public Component getTableCellRendererComponent(JTable table, Object value,
          boolean isSelected, boolean hasFocus, int row, int column) {
          JTableHeader header = table.getTableHeader();
          if (header != null) {
            setForeground(header.getForeground());
            setBackground(header.getBackground());
            setFont(header.getFont());
          }
          setHorizontalAlignment(JLabel.CENTER);
          setText((value == null) ? "" : value.toString());
          setBorder(UIManager.getBorder("TableHeader.cellBorder"));
          return this;
        }
      };
    }
    else {
      this.renderer = renderer;
    }
    this.text = text;
    v = new Vector();
  }
 
  /**
   * @param obj    TableColumn or ColumnGroup
   */
  public void add(Object obj) {
    if (obj == null) { return; }
    v.addElement(obj);
  }
 
  /**
   * @param c    TableColumn
   * @param v    ColumnGroups
   */
  public Vector getColumnGroups(TableColumn c, Vector g) {
    g.addElement(this);
    if (v.contains(c)) {
      return g;
    }
    Enumeration enumeration = v.elements();
    while (enumeration.hasMoreElements()) {
      Object obj = enumeration.nextElement();
      if (obj instanceof ColumnGroup) {
        Vector groups =
          (Vector) ( (ColumnGroup) obj).getColumnGroups(c, (Vector) g.clone());
        if (groups != null) {
          return groups;
        }
      }
    }
    return null;
  }
 
  public TableCellRenderer getHeaderRenderer() {
    return renderer;
  }
 
  public void setHeaderRenderer(TableCellRenderer renderer) {
    if (renderer != null) {
      this.renderer = renderer;
    }
  }
 
  public Object getHeaderValue() {
    return text;
  }
 
  public Dimension getSize(JTable table) {
    Component comp = renderer.getTableCellRendererComponent(
      table, getHeaderValue(), false, false, -1, -1);
    int height = comp.getPreferredSize().height;
    int width = 0;
    Enumeration enumeration = v.elements();
    while (enumeration.hasMoreElements()) {
      Object obj = enumeration.nextElement();
      if (obj instanceof TableColumn) {
        TableColumn aColumn = (TableColumn) obj;
        width += aColumn.getWidth();
        width += margin;
      }
      else {
        width += ( (ColumnGroup) obj).getSize(table).width;
      }
    }
    return new Dimension(width, height);
  }
 
  public void setColumnMargin(int margin) {
    this.margin = margin;
    Enumeration enumeration = v.elements();
    while (enumeration.hasMoreElements()) {
      Object obj = enumeration.nextElement();
      if (obj instanceof ColumnGroup) {
        ( (ColumnGroup) obj).setColumnMargin(margin);
      }
    }
  }
}

Classe GroupableTableHeader

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
 
package test;
 
import java.util.Enumeration;
import java.util.Vector;
 
import javax.swing.table.JTableHeader;
import javax.swing.table.TableColumn;
import javax.swing.table.TableColumnModel;
 
public class GroupableTableHeader
  extends JTableHeader
{
  private static final String uiClassID = "GroupableTableHeaderUI";
  protected Vector columnGroups = null;
 
  public GroupableTableHeader()
  {
    super();
    setUI(new GroupableTableHeaderUI());
    setReorderingAllowed(false);
  }
 
  public GroupableTableHeader(TableColumnModel model)
  {
    super(model);
    setUI(new GroupableTableHeaderUI());
    setReorderingAllowed(false);
  }
 
  public void setReorderingAllowed(boolean b)
  {
    reorderingAllowed = false;
  }
 
  public void addColumnGroup(ColumnGroup g)
  {
    if (columnGroups == null)
    {
      columnGroups = new Vector();
    }
    columnGroups.addElement(g);
  }
 
  public Enumeration getColumnGroups(TableColumn col)
  {
    if (columnGroups == null)
    {
      return null;
    }
    Enumeration enumeration = columnGroups.elements();
    while (enumeration.hasMoreElements())
    {
      ColumnGroup cGroup = (ColumnGroup) enumeration.nextElement();
      Vector v_ret = (Vector) cGroup.getColumnGroups(col, new Vector());
      if (v_ret != null)
      {
        return v_ret.elements();
      }
    }
    return null;
  }
 
  public void setColumnMargin()
  {
    if (columnGroups == null)
    {
      return;
    }
    //int columnMargin = getColumnModel().getColumnMargin();
    int columnMargin = getColumnModel().getColumnMargin() - 1;
    Enumeration enumeration = columnGroups.elements();
    while (enumeration.hasMoreElements())
    {
      ColumnGroup cGroup = (ColumnGroup) enumeration.nextElement();
      cGroup.setColumnMargin(columnMargin);
    }
  }
}

Classe GroupableTableHeaderUI

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
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
 
package test;
 
import java.util.Enumeration;
import java.util.Hashtable;
 
import java.awt.Component;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Rectangle;
import javax.swing.JComponent;
import javax.swing.plaf.basic.BasicTableHeaderUI;
import javax.swing.table.TableCellRenderer;
import javax.swing.table.TableColumn;
import javax.swing.table.TableColumnModel;
 
public class GroupableTableHeaderUI
  extends BasicTableHeaderUI
{
 
  public void paint(Graphics g, JComponent c)
  {
    Rectangle clipBounds = g.getClipBounds();
    if (header.getColumnModel() == null)
    {
      return;
    }
    ( (GroupableTableHeader) header).setColumnMargin();
    int column = 0;
    Dimension size = header.getSize();
    Rectangle cellRect = new Rectangle(0, 0, size.width, size.height);
    Hashtable h = new Hashtable();
    //int columnMargin = header.getColumnModel().getColumnMargin();
 
    Enumeration enumeration = header.getColumnModel().getColumns();
    while (enumeration.hasMoreElements())
    {
      cellRect.height = size.height;
      cellRect.y = 0;
      TableColumn aColumn = (TableColumn) enumeration.nextElement();
      Enumeration cGroups = ( (GroupableTableHeader) header).getColumnGroups(aColumn);
      if (cGroups != null)
      {
        int groupHeight = 0;
        while (cGroups.hasMoreElements())
        {
          ColumnGroup cGroup = (ColumnGroup) cGroups.nextElement();
          Rectangle groupRect = (Rectangle) h.get(cGroup);
          if (groupRect == null)
          {
            groupRect = new Rectangle(cellRect);
            Dimension d = cGroup.getSize(header.getTable());
            groupRect.width = d.width;
            groupRect.height = d.height;
            h.put(cGroup, groupRect);
          }
          paintCell(g, groupRect, cGroup);
          groupHeight += groupRect.height;
          cellRect.height = size.height - groupHeight;
          cellRect.y = groupHeight;
        }
      }
      //cellRect.width = aColumn.getWidth() + columnMargin;
      cellRect.width = aColumn.getWidth();
      if (cellRect.intersects(clipBounds))
      {
        paintCell(g, cellRect, column);
      }
      cellRect.x += cellRect.width;
      column++;
    }
  }
 
  private void paintCell(Graphics g, Rectangle cellRect, int columnIndex)
  {
    TableColumn aColumn = header.getColumnModel().getColumn(columnIndex);
    //TableCellRenderer renderer = aColumn.getHeaderRenderer();
    TableCellRenderer renderer = header.getDefaultRenderer();
    Component component = renderer.getTableCellRendererComponent(
      header.getTable(), aColumn.getHeaderValue(), false, false, -1, columnIndex);
    rendererPane.add(component);
    rendererPane.paintComponent(g, component, header, cellRect.x, cellRect.y,
                                cellRect.width, cellRect.height, true);
  }
 
  private void paintCell(Graphics g, Rectangle cellRect, ColumnGroup cGroup)
  {
    TableCellRenderer renderer = cGroup.getHeaderRenderer();
    Component component = renderer.getTableCellRendererComponent(
      header.getTable(), cGroup.getHeaderValue(), false, false, -1, -1);
    rendererPane.add(component);
    rendererPane.paintComponent(g, component, header, cellRect.x, cellRect.y,
                                cellRect.width, cellRect.height, true);
  }
 
  private int getHeaderHeight()
  {
    int height = 0;
    TableColumnModel columnModel = header.getColumnModel();
    for (int column = 0; column < columnModel.getColumnCount(); column++)
    {
      TableColumn aColumn = columnModel.getColumn(column);
      //TableCellRenderer renderer = aColumn.getHeaderRenderer();
      TableCellRenderer renderer = header.getDefaultRenderer();
 
      Component comp = renderer.getTableCellRendererComponent(
        header.getTable(), aColumn.getHeaderValue(), false, false, -1, column);
      int cHeight = comp.getPreferredSize().height;
      Enumeration enumeration = ( (GroupableTableHeader) header).getColumnGroups(aColumn);
      if (enumeration != null)
      {
        while (enumeration.hasMoreElements())
        {
          ColumnGroup cGroup = (ColumnGroup) enumeration.nextElement();
          cHeight += cGroup.getSize(header.getTable()).height;
        }
      }
      height = Math.max(height, cHeight);
    }
    return height;
  }
 
  private Dimension createHeaderSize(long width)
  {
    TableColumnModel columnModel = header.getColumnModel();
    width += columnModel.getColumnMargin() * columnModel.getColumnCount();
    if (width > Integer.MAX_VALUE)
    {
      width = Integer.MAX_VALUE;
    }
    return new Dimension( (int) width, getHeaderHeight());
  }
 
  public Dimension getPreferredSize(JComponent c)
  {
    long width = 0;
    Enumeration enumeration = header.getColumnModel().getColumns();
    while (enumeration.hasMoreElements())
    {
      TableColumn aColumn = (TableColumn) enumeration.nextElement();
      width = width + aColumn.getPreferredWidth();
    }
    return createHeaderSize(width);
  }
}

Classe JTableTest

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
 
package test;
 
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.Insets;
 
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.event.TableModelEvent;
import javax.swing.table.JTableHeader;
import javax.swing.table.TableColumnModel;
 
import test.*;
 
public class JTableTest extends JPanel
{
  private JTable testTable;
 
  public JTableTest()
  {
    initialize();
  }
 
  private void initialize()
  {
    this.setLayout(new GridBagLayout());
 
    testTable = new JTable(10, 13)
    {
      protected JTableHeader createDefaultTableHeader()
      {
        return new GroupableTableHeader(columnModel);
      }
    };
 
    setNestingDisplay(testTable);
 
    JScrollPane scrollPane = new JScrollPane(testTable);
 
    this.add(scrollPane, new GridBagConstraints(0, 1, 1, 1, 1.0, 1.0,
      GridBagConstraints.NORTHWEST, GridBagConstraints.BOTH, new Insets(0, 0, 0, 0), 0, 0));
 
    this.setVisible(true);
  }
 
  protected static void setNestingDisplay(JTable table)
  {
 
	TableColumnModel cm = table.getColumnModel();
    ColumnGroup group1 = new ColumnGroup("Group1");
 
    ColumnGroup subgroup1 = new ColumnGroup("Sub-Group1");
    subgroup1.add(cm.getColumn(5));
    subgroup1.add(cm.getColumn(6));
 
    ColumnGroup subgroup2 = new ColumnGroup("Sub-Group2");
    subgroup2.add(cm.getColumn(7));
    subgroup2.add(cm.getColumn(8));
 
    group1.add(subgroup1);
    group1.add(subgroup2);
 
    ColumnGroup group2 = new ColumnGroup("Group2");
 
    ColumnGroup subgroup3 = new ColumnGroup("Sub-Group3");
    subgroup3.add(cm.getColumn(9));
    subgroup3.add(cm.getColumn(10));
 
    ColumnGroup subgroup4 = new ColumnGroup("Sub-Group4");
    subgroup4.add(cm.getColumn(11));
    subgroup4.add(cm.getColumn(12));
 
    group2.add(subgroup3);
    group2.add(subgroup4);
 
    GroupableTableHeader header = (GroupableTableHeader)table.getTableHeader();
    header.addColumnGroup(group1);
    header.addColumnGroup(group2);
    table.setTableHeader(header);
  }
 
  /* TEST */
  public static void main(String args[])
  {
    // Quick main to test the display
    javax.swing.JFrame frame = new javax.swing.JFrame();
    frame.setContentPane(new JTableTest());
    frame.pack();
    frame.setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
    frame.setVisible(true);
  }
}

Ce code fonctionne bien en java 1.4
mais dès que l'on passe en java 5
on perd les colonnes qui possèdent
des sous colonnes.

Si quelqu'un a une idée je suis fortement preneur

Merci à tous