EclipseRCP开发之如何让表格中的各列随表格的变化始终充满整个表格

 

1. package com.winscad.util;   
2.   
3. import java.util.ArrayList;   
4. import java.util.List;   
5.   
6. import org.eclipse.jface.viewers.ColumnLayoutData;   
7. import org.eclipse.jface.viewers.ColumnPixelData;   
8. import org.eclipse.jface.viewers.ColumnWeightData;   
9. import org.eclipse.jface.viewers.TableLayout;   
10. import org.eclipse.swt.events.ControlEvent;   
11. import org.eclipse.swt.events.ControlListener;   
12. import org.eclipse.swt.widgets.Table;   
13. import org.eclipse.swt.widgets.TableColumn;   
14.   
15. public class AutoResizeTableLayout extends TableLayout implements ControlListener ...{   
16.     private final Table table;   
17.   
18.     private List columns = new ArrayList();   
19.   
20.     private boolean autosizing = false;   
21.   
22.     public AutoResizeTableLayout(Table table) ...{   
23.         this.table = table;   
24.         table.addControlListener(this);   
25.     }   
26.   
27.     public void addColumnData(ColumnLayoutData data) ...{   
28.         columns.add(data);   
29.         super.addColumnData(data);   
30.     }   
31.   
32.     public void controlMoved(ControlEvent e) ...{   
33.     }   
34.   
35.     public void controlResized(ControlEvent e) ...{   
36.         if (autosizing)   
37.             return;   
38.         autosizing = true;   
39.         try ...{   
40.             autoSizeColumns();   
41.         } finally ...{   
42.             autosizing = false;   
43.         }   
44.     }   
45.   
46.     private void autoSizeColumns() ...{   
47.         int width = table.getClientArea().width;   
48.   
49.         // XXX: Layout is being called with an invalid value   
50.         // the first time it is being called on Linux.   
51.         // This method resets the layout to null,   
52.         // so we run it only when the value is OK.   
53.         if (width <= 1)   
54.             return;   
55.   
56.         TableColumn[] tableColumns = table.getColumns();   
57.         int size = Math.min(columns.size(), tableColumns.length);   
58.         int[] widths = new int[size];   
59.         int fixedWidth = 0;   
60.         int numberOfWeightColumns = 0;   
61.         int totalWeight = 0;   
62.   
63.         // First calculate space occupied by fixed columns.   
64.         for (int i = 0; i < size; i++) ...{   
65.             ColumnLayoutData col = (ColumnLayoutData) columns.get(i);   
66.             if (col instanceof ColumnPixelData) ...{   
67.                 int pixels = ((ColumnPixelData) col).width;   
68.                 widths[i] = pixels;   
69.                 fixedWidth += pixels;   
70.             } else if (col instanceof ColumnWeightData) ...{   
71.                 ColumnWeightData cw = (ColumnWeightData) col;   
72.                 numberOfWeightColumns++;   
73.                 int weight = cw.weight;   
74.                 totalWeight += weight;   
75.             } else ...{   
76.                 throw new IllegalStateException("Unknown column layout data");   
77.             }   
78.         }   
79.         // Do we have columns that have a weight?   
80.         if (numberOfWeightColumns > 0) ...{   
81.             // Now, distribute the rest   
82.             // to the columns with weight.   
83.             int rest = width - fixedWidth;   
84.             int totalDistributed = 0;   
85.             for (int i = 0; i < size; i++) ...{   
86.                 ColumnLayoutData col = (ColumnLayoutData) columns.get(i);   
87.                 if (col instanceof ColumnWeightData) ...{   
88.                     ColumnWeightData cw = (ColumnWeightData) col;   
89.                     int weight = cw.weight;   
90.                     int pixels = totalWeight == 0 ? 0 : weight * rest   
91.                             / totalWeight;   
92.                     if (pixels < cw.minimumWidth)   
93.                         pixels = cw.minimumWidth;   
94.                     totalDistributed += pixels;   
95.                     widths[i] = pixels;   
96.                 }   
97.             }   
98.   
99.             // Distribute any remaining pixels   
100.             // to columns with weight.   
101.             int diff = rest - totalDistributed;   
102.             for (int i = 0; diff > 0; i++) ...{   
103.                 if (i == size)   
104.                     i = 0;   
105.                 ColumnLayoutData col = (ColumnLayoutData) columns.get(i);   
106.                 if (col instanceof ColumnWeightData) ...{   
107.                     ++widths[i];   
108.                     --diff;   
109.                 }   
110.             }   
111.         }   
112.   
113.         for (int i = 0; i < size; i++) ...{   
114.             if (tableColumns[i].getWidth() != widths[i])   
115.                 tableColumns[i].setWidth(widths[i]);   
116.         }   
117.     }   
118. }  

 

然后在需要各列自动充满整个表格的表格中加上如下代码：

 

   AutoResizeTableLayout layout = new AutoResizeTableLayout(tableRegionListInfo);   

•         tableRegionListInfo.setLayout(layout);   
• 其中tableRegionListInfo为需要各列自动充满整个表格的表格（Table）  

  最后在表格中的各列中加上如下代码：
  layout.addColumnData(new ColumnWeightData(200));
  其中200代表此列在表格中所占的比例，例如在另外一列后面设置
  layout.addColumnData(new ColumnWeightData(400));则此列在表格中所占的比例是上一个表格的两倍。