001: package com.calipso.reportgenerator.userinterface;
002:
003: import javax.swing.*;
004: import com.calipso.reportgenerator.common.HeaderTableModel;
005: import com.calipso.reportgenerator.common.LanguageTraslator;
006: import com.calipso.reportgenerator.reportcalculator.SharedFloat;
007: import org.jfree.data.category.DefaultCategoryDataset;
008:
009: /**
010: * Representa tanto los datos a la hora de ejecutar un chart
011: * como tambien las descripciones que corresponden a esos datos
012: */
013: public class ChartData {
014:
015: private JTable dataTable;
016: private HeaderTableModel rowHeaderTableModel;
017: private HeaderTableModel columnHeaderTableModel;
018:
019: /**Inicializa un objeto de tipo ChartData
020: * @param dataTable contiene los datos a obtener
021: * @param rowHeaderTableModel contiene las descripciones para la ejecucion de un chart por filas
022: * @param columnHeaderTableModel contiene las descripciones para la ejecucion de un chart por columnas
023: */
024: public ChartData(JTable dataTable,
025: HeaderTableModel rowHeaderTableModel,
026: HeaderTableModel columnHeaderTableModel) {
027: this .dataTable = dataTable;
028: this .rowHeaderTableModel = rowHeaderTableModel;
029: this .columnHeaderTableModel = columnHeaderTableModel;
030: }
031:
032: /**
033: * Obtiene un Array que representa los datos seleccionados a la hora de
034: * ejecutar un chart de tipo Torta
035: * @return devuelve un array de double
036: */
037: public double[] getChartDataArray() {
038: double[] chartDataArray = null;
039: int[] selectedRows = dataTable.getSelectedRows();
040: int[] selectedColumns = dataTable.getSelectedColumns();
041:
042: double total = 0;
043: if (selectedRows.length > 1) {
044: chartDataArray = new double[selectedRows.length];
045: int selectedColumn = dataTable.getSelectedColumn();
046: for (int i = 0; i < selectedRows.length; i++) {
047: chartDataArray[i] = Double.valueOf(
048: dataTable.getValueAt(selectedRows[i],
049: selectedColumn).toString())
050: .doubleValue();
051: total = total + chartDataArray[i];
052: }
053:
054: } else {
055: chartDataArray = new double[selectedColumns.length];
056: int selectedRow = dataTable.getSelectedRow();
057: for (int i = 0; i < selectedColumns.length; i++) {
058: chartDataArray[i] = Double.valueOf(
059: dataTable.getValueAt(selectedRow,
060: selectedColumns[i]).toString())
061: .doubleValue();
062: total = total + chartDataArray[i];
063: }
064:
065: }
066:
067: for (int i = 0; i < chartDataArray.length; i++) {
068: chartDataArray[i] = (chartDataArray[i] * 100) / total;
069: }
070:
071: return chartDataArray;
072: }
073:
074: /**Obtiene un array de Strings que representa las descripciones que corresponden
075: * al rango de datos seleccionados en la interfaz principal.
076: * @param byRow determina si se trata de una ejecucion por filas o columnas
077: * @return String[] que contiene las descripciones
078: */
079: public String[] getDescriptionForChart(Boolean byRow) {
080: int[] selectedRows = dataTable.getSelectedRows();
081: int[] selectedColumns = dataTable.getSelectedColumns();
082: String[] descChartPie;
083: if (((selectedRows.length > 1) && (byRow == null))
084: || ((byRow != null) && (byRow.booleanValue()))) {
085: descChartPie = new String[selectedRows.length];
086: for (int i = 0; i < descChartPie.length; i++) {
087: Object[] rowsDesc = rowHeaderTableModel
088: .getValueFrom(selectedRows[i]);
089: descChartPie[i] = "";
090: for (int j = 0; j < rowsDesc.length; j++) {
091: if (rowsDesc[j] != null) {
092: descChartPie[i] = descChartPie[i]
093: + rowsDesc[j].toString() + " ";
094: } else {
095: descChartPie[i] = descChartPie[i] + " TOTAL";
096: }
097: }
098: }
099: } else {
100: descChartPie = new String[selectedColumns.length];
101: for (int i = 0; i < descChartPie.length; i++) {
102: Object[] colsDesc = columnHeaderTableModel
103: .getValueFrom(selectedColumns[i]);
104: for (int j = 0; j < colsDesc.length; j++) {
105: descChartPie[i] = "";
106: if (colsDesc != null) {
107: descChartPie[i] = descChartPie[i]
108: + colsDesc[j].toString() + "/";
109: } else {
110: descChartPie[i] = descChartPie[i] + " TOTAL";
111: }
112: }
113: }
114: }
115: return descChartPie;
116: }
117:
118: /**
119: * Devuelve el DefaultCategoryDataset que se necesita para generar el chart
120: * dependiendo si es por filas o por columnas
121: * @param isRow especifica si el chart a generar es en base a filas o columnas
122: * @return DefaultCategoryDataset dato necesario para generar el chart
123: */
124: public DefaultCategoryDataset getDatasetForChart(boolean isRow) {
125: DefaultCategoryDataset dataset = null;
126: int[] selectedRows = dataTable.getSelectedRows();
127: int[] selectedColumns = dataTable.getSelectedColumns();
128: if ((selectedRows.length == 0 && selectedColumns.length == 0)
129: || (selectedRows.length == 1 && selectedColumns.length == 1)) {
130: int[] rows = getIndexes(dataTable.getRowCount());
131: int[] cols = getIndexes(dataTable.getColumnCount());
132: dataset = getDataForChart(cols, rows, isRow);
133: } else {
134: dataset = getDataForChart(selectedColumns, selectedRows,
135: isRow);
136: }
137: return dataset;
138: }
139:
140: private int[] getIndexes(int count) {
141: int[] objects = new int[count];
142: for (int i = 0; i < count; i++) {
143: objects[i] = i;
144: }
145: return objects;
146: }
147:
148: /**
149: * Devuelve el DefaultCategoryDataset que se necesita para generar el chart
150: * @param firstList
151: * @param secondList
152: * @param isRow
153: * @return dataset
154: */
155: private DefaultCategoryDataset getDataForChart(int[] firstList,
156: int[] secondList, boolean isRow) {
157: float numbersArray = 0;
158: String factorArray = null;
159: String seriesArray = null;
160: DefaultCategoryDataset dataset = new DefaultCategoryDataset();
161: for (int i = 0; i < firstList.length; i++) {
162: if (isRow) {
163: seriesArray = getDescription(columnHeaderTableModel
164: .getValueFrom(firstList[i]));
165: } else {
166: factorArray = getDescription(columnHeaderTableModel
167: .getValueFrom(firstList[i]));
168: }
169: for (int j = 0; j < secondList.length; j++) {
170: if (((dataTable.getValueAt(secondList[j], firstList[i]) == null))
171: || ((((SharedFloat) dataTable.getValueAt(
172: secondList[j], firstList[i]))
173: .getValue()
174: .equals(new Float(Float.NaN))))) {
175: numbersArray = 0;
176: } else {
177: numbersArray = Float.valueOf(
178: dataTable.getValueAt(secondList[j],
179: firstList[i]).toString())
180: .floatValue();
181: }
182: if (isRow) {
183: factorArray = getDescription(rowHeaderTableModel
184: .getValueFrom(secondList[j]));
185: } else {
186: seriesArray = getDescription(rowHeaderTableModel
187: .getValueFrom(secondList[j]));
188: }
189: dataset
190: .addValue(numbersArray, seriesArray,
191: factorArray);
192: }
193: }
194: return dataset;
195: }
196:
197: /**
198: * Devuelve la descripcion necesaria que se visualizara en el chart
199: * @param descArray descripcion que se visualizara en el chart
200: * @return String que representa la descripcion
201: */
202: private String getDescription(Object[] descArray) {
203: String description = "";
204: for (int i = 0; i < descArray.length; i++) {
205: if (descArray[i] != null) {
206: description = description + descArray[i].toString()
207: + " ";
208: } else {
209: description = description
210: + LanguageTraslator.traslate("358");
211: }
212: }
213: return description;
214: }
215:
216: }
|