KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > compiere > report > core > ResultTable


1 /******************************************************************************
2  * The contents of this file are subject to the Compiere License Version 1.1
3  * ("License"); You may not use this file except in compliance with the License
4  * You may obtain a copy of the License at http://www.compiere.org/license.html
5  * Software distributed under the License is distributed on an "AS IS" basis,
6  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for
7  * the specific language governing rights and limitations under the License.
8  * The Original Code is Compiere ERP & CRM Business Solution
9  * The Initial Developer of the Original Code is Jorg Janke and ComPiere, Inc.
10  * Portions created by Jorg Janke are Copyright (C) 1999-2001 Jorg Janke, parts
11  * created by ComPiere are Copyright (C) ComPiere, Inc.; All Rights Reserved.
12  * Contributor(s): ______________________________________.
13  *****************************************************************************/
14 package org.compiere.report.core;
15
16 import java.awt.*;
17 import java.awt.event.*;
18 import javax.swing.*;
19 import javax.swing.event.*;
20 import javax.swing.table.*;
21 import java.util.*;
22
23 import org.compiere.util.*;
24
25 /**
26  * The Table to present RModel information
27  *
28  * @author Jorg Janke
29  * @version $Id: ResultTable.java,v 1.6 2002/05/26 01:20:12 jjanke Exp $
30  */
31 public class ResultTable extends JTable implements MouseListener
32 {
33     /**
34      * Constructor
35      */
36     public ResultTable()
37     {
38         super();
39         setCellSelectionEnabled(false);
40         setColumnSelectionAllowed(false);
41         setRowSelectionAllowed(false);
42         setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
43         setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
44
45         // Default Editor
46 ResultTableCellEditor rtce = new ResultTableCellEditor();
47         setCellEditor(rtce);
48
49         // Mouse Listener
50 addMouseListener(this);
51         getTableHeader().addMouseListener(this);
52     } // ResultTable
53
54     /** Last model index sorted */
55     private int m_lastSortIndex = -1;
56     /** Sort direction */
57     private boolean m_asc = true;
58
59     /**
60      * Create a JTable Model from ReportModel
61      * @param reportModel
62      * @param locale
63      */
64     public ResultTable (RModel reportModel)
65     {
66         this();
67         setModel(reportModel);
68     } // ResultTable
69
70     /**
71      * Set Model
72      * @param reportModel
73      */
74     public void setModel (RModel reportModel)
75     {
76         Log.trace(Log.l3_Util, "ResultTable.setModel");
77         super.setModel(new ResultTableModel(reportModel));
78         //
79 TableColumnModel tcm = getColumnModel();
80         // Set Editor/Renderer
81 for (int i = 0; i < tcm.getColumnCount(); i++)
82         {
83             TableColumn tc = tcm.getColumn(i);
84             RColumn rc = reportModel.getRColumn(i);
85             if (rc.getColHeader().equals(tc.getHeaderValue()))
86             {
87                 ResultTableCellRenderer rtcr = new ResultTableCellRenderer(reportModel, rc);
88                 tc.setCellRenderer(rtcr);
89                 //
90 }
91             else
92                 Log.error("RColumn=" + rc.getColHeader() + " <> TableColumn=" + tc.getHeaderValue());
93         }
94         autoSize();
95     } // setModel
96
97     /**
98      * Set Model
99      * @param ignored
100      */
101     public void setModel (TableModel ignored)
102     {
103         // throw new IllegalArgumentException("Requires RModel"); // default construvtor calls this
104 super.setModel(ignored);
105     } // setModel
106
107     /**
108      * Table Model Listener
109      * @param e
110      */
111     public void tableChanged(TableModelEvent e)
112     {
113         super.tableChanged(e);
114         Log.trace(Log.l6_Database, "ResultTable.tableChanged - Type=" + e.getType());
115     } // tableChanged
116
117     /*************************************************************************/
118
119     /**
120      * Mouse Clicked
121      * @param e
122      */
123     public void mouseClicked(MouseEvent e)
124     {
125         int col = getColumnModel().getColumnIndexAtX(e.getX());
126         Log.trace(Log.l1_User, "ResultTable.mouseClicked",
127             "Column " + col + " = " + getColumnModel().getColumn(col).getHeaderValue()
128             + ", Table r=" + this.getSelectedRow() + " c=" + this.getSelectedColumn());
129
130         // clicked Cell
131 if (e.getSource() == this)
132         {
133         }
134         // clicked Header
135 else
136         {
137             int mc = convertColumnIndexToModel(col);
138             sort(mc);
139         }
140     } // mouseClicked
141
142     public void mousePressed(MouseEvent e)
143     {
144     }
145     public void mouseReleased(MouseEvent e)
146     {
147     }
148     public void mouseEntered(MouseEvent e)
149     {
150     }
151     public void mouseExited(MouseEvent e)
152     {
153     }
154
155     /*************************************************************************/
156
157     /**
158      * Size Columns
159      */
160     private void autoSize()
161     {
162         Log.trace(Log.l4_Data, "ResultTable.autoSize");
163         //
164 final int SLACK = 8; // making sure it fits in a column
165 final int MAXSIZE = 300; // max size of a column
166 //
167 TableColumnModel tcm = getColumnModel();
168         // For all columns
169 for (int col = 0; col < tcm.getColumnCount(); col++)
170         {
171             TableColumn tc = tcm.getColumn(col);
172         // Log.trace(Log.l4_Data, "Column=" + col, tc.getHeaderValue());
173 int width = 0;
174
175             // Header
176 TableCellRenderer renderer = tc.getHeaderRenderer();
177             if (renderer == null)
178                 renderer = new DefaultTableCellRenderer();
179             Component comp = renderer.getTableCellRendererComponent
180                 (this, tc.getHeaderValue(), false, false, 0, 0);
181         // Log.trace(Log.l5_DData, "Hdr - preferred=" + comp.getPreferredSize().width + ", width=" + comp.getWidth());
182 width = comp.getPreferredSize().width + SLACK;
183
184             // Cells
185 int maxRow = Math.min(30, getRowCount()); // first 30 rows
186 for (int row = 0; row < maxRow; row++)
187             {
188                 renderer = getCellRenderer(row, col);
189                 comp = renderer.getTableCellRendererComponent
190                     (this, getValueAt(row, col), false, false, row, col);
191                 int rowWidth = comp.getPreferredSize().width + SLACK;
192                 width = Math.max(width, rowWidth);
193             }
194             // Width not greater ..
195 width = Math.min(MAXSIZE, width);
196             tc.setPreferredWidth(width);
197         // Log.trace(Log.l5_DData, "width=" + width);
198 } // for all columns
199 } // autoSize
200
201     /**
202      * Sort Table
203      * @param modelColumnIndex
204      */
205     private void sort (int modelColumnIndex)
206     {
207         int rows = getRowCount();
208         if (rows == 0)
209             return;
210         // other column
211 if (modelColumnIndex != m_lastSortIndex)
212             m_asc = true;
213         else
214             m_asc = !m_asc;
215
216         m_lastSortIndex = modelColumnIndex;
217         //
218 Log.trace(Log.l4_Data, "ResultTable.sort #" + modelColumnIndex,
219             "rows=" + rows + ", asc=" + m_asc);
220         ResultTableModel model = (ResultTableModel)getModel();
221
222         // Prepare sorting
223 MSort sort = new MSort(0, null);
224         sort.setSortAsc(m_asc);
225         // while something to sort
226 sorting:
227         while (true)
228         {
229             // Create sortList
230 ArrayList sortList = new ArrayList(rows);
231             // fill with data entity
232 for (int i = 0; i < rows; i++)
233             {
234                 Object JavaDoc value = model.getValueAt(i, modelColumnIndex);
235                 sortList.add(new MSort(i, value));
236             }
237             // sort list it
238 Collections.sort(sortList, sort);
239             // move out of sequence row
240 for (int i = 0; i < rows; i++)
241             {
242                 int index = ((MSort)sortList.get(i)).index;
243                 if (i != index)
244                 {
245             // Log.trace(Log.l4_Data, "move " + i + " to " + index);
246 model.moveRow (i, index);
247                     continue sorting;
248                 }
249             }
250             // we are done
251 // Log.trace(Log.l4_Data, "done");
252 break;
253         } // while something to sort
254 } // sort
255
256 } // ResultTable
257
Popular Tags