KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > calipso > reportgenerator > userinterface > HeaderTableUI


1 package com.calipso.reportgenerator.userinterface;
2
3 import com.calipso.reportgenerator.common.DimensionValueNode;
4 import com.calipso.reportgenerator.common.HeaderTableModel;
5
6 import javax.swing.*;
7 import javax.swing.plaf.basic.BasicTableUI JavaDoc;
8 import java.awt.*;
9 import java.util.Iterator JavaDoc;
10 import java.util.Map JavaDoc;
11 import java.util.Vector JavaDoc;
12
13 /**
14  * Se encarga de dibujar las tablas con encabezados agrupados
15  */
16
17 public abstract class HeaderTableUI extends BasicTableUI JavaDoc {
18
19   //Contador para la posicion de las celdas (permite determinar una celda fuera de los limites)
20 protected int count=0;
21   //Auxiliar para llenar el vector endings
22 protected int iterations = 0;
23   //Vector que contiene los numeros de celda donde termina un grupo de nivel 0
24 protected Vector JavaDoc endings = null;
25
26   public HeaderTableUI() {
27   }
28
29   /**
30    * Devuelve el Modelo de la tabla
31    * @return
32    */
33   protected HeaderTableModel getModel() {
34     return (HeaderTableModel) table.getModel();
35   }
36
37
38   /**
39    * Devuelve el modo en que debe dibujarse la tabla (si por fila o por columna)
40    * @return
41    */
42   protected int getMode() {
43     return getModel().getMode();
44   }
45
46   /**
47    * Devuelve todos los subnodos del arbol de grupos
48    * @return
49    */
50   protected Map JavaDoc getAllSubNodes() {
51     return getModel().getDimensionValueNode().getAllSubNodes();
52   }
53
54
55   /**
56    * Pinta el componente
57    * @param g
58    * @param c
59    */
60   public void paint(Graphics g, JComponent c) {
61     table.clearSelection();
62     paintCells(g);
63   }
64
65
66   /**
67    * Inicia la recorrida del arbol de grupos para pintar cada nodo
68    * @param g
69    */
70   protected void paintCells(Graphics g) {
71     int from = getFromCell();
72     int to = getToCell();
73     DimensionValueNode root = getModel().getDimensionValueNode();
74     int[] rowIndexes = new int[root.getDimensionCount()];
75     int[] rowSizes = new int[root.getDimensionCount()];
76     count = 0;
77     paintNode(root, g, rowIndexes, rowSizes, from, to);
78   }
79
80   /**
81    * Calcula la celda hasta la cual se debe dibujar
82    * @return celda donde finaliza el dibujo
83    */
84   protected abstract int getToCell();
85
86   /**
87    * Calcula la celda desde la cual se debe imprimir
88    * @return primera celda a dibujar
89    */
90   protected abstract int getFromCell();
91
92 /* protected void paintNode(DimensionValueNode node, Graphics g, int[] rowIndexes, int[] rowSizes) {
93     if (!node.getCollapsed()) {
94       for (Iterator iterator = node.getSubNodesList().iterator(); iterator.hasNext();) {
95         DimensionValueNode dimensionValueNode = (DimensionValueNode) iterator.next();
96         paintNode(dimensionValueNode, g, rowIndexes, rowSizes);
97       }
98     }
99     else {
100       if (!getModel().getWithTotals()) {
101         for (int i = node.getDimesionIndex() + 1; i < getModel().getDimensionCount(); i++) {
102           if (getMode() == HeaderTableModel.MODE_ROW){
103             rowIndexes[i]++;
104           }
105           else {
106             rowIndexes[i]+= getModel().getVisibleMetricsCount();
107           }
108         }
109         for (int i = 0; i <= node.getDimesionIndex(); i++) {
110           if (getMode() == HeaderTableModel.MODE_ROW){
111             rowSizes[i]++;
112           }
113           else {
114             rowSizes[i]+= getModel().getVisibleMetricsCount();
115           }
116         }
117       }
118     }
119     doPaintNode(node, g, rowIndexes, rowSizes);
120     if (node.getDimesionIndex() >= 0) {
121       rowSizes[node.getDimesionIndex()] = 0;
122     }
123   }*/
124
125   /**
126    * Pinta un nodo del arbol de grupos, si el nodo tiene subnodos, primero pinta los de nivel inferior.
127    * @param node
128    * @param g
129    * @param rowIndexes
130    * @param rowSizes
131    * @param from
132    * @param to
133    */
134   protected void paintNode(DimensionValueNode node, Graphics g, int[] rowIndexes, int[] rowSizes, int from, int to) {
135     if (!node.getCollapsed()) {
136       for (Iterator JavaDoc iterator = node.getSubNodesList().iterator(); iterator.hasNext();) {
137         DimensionValueNode dimensionValueNode = (DimensionValueNode) iterator.next();
138         paintNode(dimensionValueNode, g, rowIndexes, rowSizes, from, to);
139       }
140     }
141     else {
142       if (!getModel().getWithTotals()) {
143         for (int i = node.getDimesionIndex() + 1; i < getModel().getDimensionCount(); i++) {
144           if (getMode() == HeaderTableModel.MODE_ROW){
145             rowIndexes[i]++;
146           }
147           else {
148             rowIndexes[i]+= getModel().getVisibleMetricsCount();
149           }
150         }
151         for (int i = 0; i <= node.getDimesionIndex(); i++) {
152           if (getMode() == HeaderTableModel.MODE_ROW){
153             rowSizes[i]++;
154           }
155           else {
156             rowSizes[i]+= getModel().getVisibleMetricsCount();
157           }
158         }
159       }
160     }
161     doPaintNode(node, g, rowIndexes, rowSizes, from, to);
162     if (node.getDimesionIndex() >= 0) {
163       rowSizes[node.getDimesionIndex()] = 0;
164     }
165   }
166
167 /* protected void doPaintNode(DimensionValueNode node, Graphics g, int[] rowIndexes, int[] rowSizes) {
168     Rectangle rect = null;
169     int nodeDimIndex = node.getDimesionIndex();
170     int dimCount = getModel().getDimensionCount();
171     boolean isLastDim = nodeDimIndex == dimCount - 1;
172     if (isLastDim) {
173       for (int i = 0; i < dimCount - 1; i++) {
174         rowSizes[i]++;
175       }
176     }
177     if (getModel().getWithTotals() && !isLastDim) {
178       if (node.getCollapsed()) {
179         for (int i = 0; i <= nodeDimIndex; i++) {
180           rowSizes[i]++;
181         }
182         for (int i = nodeDimIndex + 1; i < dimCount; i++) {
183           rowIndexes[i]++;
184         }
185       }
186       else {
187         int index = rowIndexes[nodeDimIndex + 1];
188         rect = getTotalRectangleFromNode(node, index);
189         getAllSubNodes().put(new Integer(index), node);
190         if ((rowSizes[0]>10) &&(rowSizes[0]<100)){
191           paintRectangle(rect, g, getGroupFooterCaption(node), false, false);
192         }
193         for (int i = 0; i <= nodeDimIndex; i++) {
194           rowSizes[i]++;
195         }
196         for (int i = nodeDimIndex + 1; i < dimCount; i++) {
197           rowIndexes[i]++;
198         }
199       }
200     }
201     if (nodeDimIndex >= 0) {
202       int size = Math.max(rowSizes[nodeDimIndex], 1);
203       int index = rowIndexes[nodeDimIndex];
204       rect = getRectangleFromNode(node, index, size);
205       if ((rowSizes[0]>10) &&(rowSizes[0]<100)){
206         paintRectangle(rect, g, node.getValue(), getNodeIsCollapsable(node), node.getCollapsed());
207       }
208       if (isLastDim) {
209         getAllSubNodes().put(new Integer(index), node);
210       }
211       rowIndexes[nodeDimIndex] += size;
212     }
213   }*/
214
215   /**
216    * Pinta la celda (o grupo de celdas) que representan a un nodo. Tanto el que representa al grupo como el total (si es
217    * necesario). Pinta solo los que se encuentren entre los parametros from y to.
218    * @param node
219    * @param g
220    * @param indexes
221    * @param sizes
222    * @param from
223    * @param to
224    */
225   protected abstract void doPaintNode(DimensionValueNode node, Graphics g, int[] indexes, int[] sizes, int from, int to);
226 /* Rectangle rect = null;
227     int nodeDimIndex = node.getDimesionIndex();
228     int dimCount = getModel().getDimensionCount();
229     boolean isLastDim = nodeDimIndex == dimCount - 1;
230     if (isLastDim) {
231       for (int i = 0; i < dimCount - 1; i++) {
232         rowSizes[i]++;
233       }
234     }
235     if (getModel().getWithTotals() && !isLastDim) {
236       if (node.getCollapsed()) {
237         for (int i = 0; i <= nodeDimIndex; i++) {
238           rowSizes[i]++;
239         }
240         for (int i = nodeDimIndex + 1; i < dimCount; i++) {
241           rowIndexes[i]++;
242         }
243       }
244       else {
245         int index = rowIndexes[nodeDimIndex + 1];
246         rect = getTotalRectangleFromNode(node, index);
247         getAllSubNodes().put(new Integer(index), node);
248         if ((count >= from) && (count <= to)){
249           paintRectangle(rect, g, getGroupFooterCaption(node), false, false);
250         }
251         count++;
252         for (int i = 0; i <= nodeDimIndex; i++) {
253           rowSizes[i]++;
254         }
255         for (int i = nodeDimIndex + 1; i < dimCount; i++) {
256           rowIndexes[i]++;
257         }
258       }
259     }
260     if (nodeDimIndex >= 0) {
261       int size = Math.max(rowSizes[nodeDimIndex], 1);
262       int index = rowIndexes[nodeDimIndex];
263       rect = getRectangleFromNode(node, index, size);
264       if ((count >= from) && (count <= to)){
265         paintRectangle(rect, g, node.getValue(), getNodeIsCollapsable(node), node.getCollapsed());
266       }
267       if (isLastDim) {
268         getAllSubNodes().put(new Integer(index), node);
269         count++;
270       }
271       rowIndexes[nodeDimIndex] += size;
272     }
273   }*/
274
275   /**
276    * Devuelve el título del pié de grupo para una nodo (que pertenece a una dimensión)
277    * @param node
278    * @return
279    */
280   protected Object JavaDoc getGroupFooterCaption(DimensionValueNode node) {
281     return getModel().getGroupFooterCaption(node.getDimesionIndex());
282   }
283
284   /**
285    * Pregunta al modelo si el nodo tiene subnodos que pueden ser colapsados
286    * @param node
287    * @return
288    */
289   protected boolean getNodeIsCollapsable(DimensionValueNode node) {
290     return getModel().getNodeIsCollapsable(node);
291   }
292
293   /**
294    * Obtiene el rectángulo que ocupan la celda o grupo de celdas que representan a un nodo y que será utilizado para
295    * pintar el componente
296    * @param node
297    * @param index
298    * @param size
299    * @return
300    */
301   protected Rectangle getRectangleFromNode(DimensionValueNode node, int index, int size) {
302     int[][] cells = ((HeaderTableModel) table.getModel()).getNodeCells(node, index, size);
303     Rectangle rect = doGetRectangle(cells);
304     return rect;
305   }
306
307   /**
308    * Obtiene el rectángulo que ocupan la celda o grupo de celdas que representan a un nodo y que será utilizado para
309    * pintar el componente
310    * @param node
311    * @param lastRow
312    * @return
313    */
314   protected Rectangle getTotalRectangleFromNode(DimensionValueNode node, int lastRow) {
315     int[][] cells = ((HeaderTableModel) table.getModel()).getTotalNodeCells(node, lastRow);
316     Rectangle rect = doGetRectangle(cells);
317     return rect;
318   }
319
320   /**
321    * arma el rectangulo que se dibuja para cada celda
322    * @param cells
323    * @return
324    */
325   protected Rectangle doGetRectangle(int[][] cells) {
326     Rectangle rect = null;
327
328     for (int index = 0; index < cells.length; index++) {
329       if (rect == null) {
330         rect = table.getCellRect(cells[index][0], cells[index][1], true);
331       }
332       else {
333         rect = rect.union(table.getCellRect(cells[index][0], cells[index][1], true));
334       }
335     }
336     return rect;
337   }
338
339   /**
340    * Dibuja la celda a partir de un rectangulo dado
341    * @param rect
342    * @param g
343    * @param value
344    * @param isCollapsable
345    */
346   protected void paintRectangle(Rectangle rect, Graphics g, Object JavaDoc value, boolean isCollapsable, boolean isCollapsed) {
347     HeaderTableRenderer renderer = (HeaderTableRenderer) table.getDefaultRenderer(Object JavaDoc.class);
348     JComponent comp = (JComponent) renderer.getCellComponent(table, value, isCollapsable, isCollapsed);
349     rendererPane.paintComponent(g, comp, table, rect.x, rect.y, rect.width, rect.height, true);
350   }
351
352   protected Vector JavaDoc getEndingsVector(){
353     if(endings==null){
354       endings = new Vector JavaDoc();
355       iterations = 0;
356       fillEndingCellForGroups(endings, getModel().getWithTotals(), getModel().getDimensionValueNode());
357     }
358     return endings;
359   }
360
361   protected abstract void fillEndingCellForGroups(Vector JavaDoc finals, boolean withTotals, DimensionValueNode dimensionValueNode);
362
363   public void resetFinals(){
364     endings = null;
365   }
366
367 }
Popular Tags