CTable


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-2002 Jorg Janke, parts
11   * created by ComPiere are Copyright (C) ComPiere, Inc.;   All Rights Reserved.
12   * Contributor(s): ______________________________________.
13   *****************************************************************************/
14  package org.compiere.swing;
15  
16  import java.awt.Component  ;
17  import java.awt.event.MouseAdapter  ;
18  import java.awt.event.MouseEvent  ;
19  import java.util.ArrayList  ;
20  import java.util.Collections  ;
21  
22  import javax.swing.JTable  ;
23  import javax.swing.ListSelectionModel  ;
24  import javax.swing.event.ChangeEvent  ;
25  import javax.swing.table.DefaultTableCellRenderer  ;
26  import javax.swing.table.DefaultTableModel  ;
27  import javax.swing.table.TableCellRenderer  ;
28  import javax.swing.table.TableColumn  ;
29  import javax.swing.table.TableModel  ;
30  
31  import org.compiere.util.MSort;
32  
33  /**
34   *  Model Independent enhanced JTable.
35   *  Provides sizing and sorting
36   *
37   *  @author     Jorg Janke
38   *  @version    $Id: CTable.java,v 1.3 2003/10/03 04:10:53 jjanke Exp $
39   */
40  public class CTable extends JTable  
41  {
42      /**
43       *  Default Constructor
44       */
45      public CTable()
46      {
47          super(new DefaultTableModel  ());
48          setColumnSelectionAllowed(false);
49          setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
50          setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
51          getTableHeader().addMouseListener(new CTableMouseListener());
52  
53  
54      }   //  CTable
55  
56      /** Last model index sorted */
57      protected int               p_lastSortIndex = -1;
58      /** Sort direction          */
59      protected boolean           p_asc = true;
60  
61      /** Sizing: making sure it fits in a column */
62      private final int           SLACK = 15;
63      /** Sizing: max size in pt                  */
64      private final int           MAXSIZE = 250;
65      /** Model Index of Key Column   */
66      protected int               p_keyColumnIndex = -1;
67  
68  
69      /**
70       *  Set Model index of Key Column.
71       *  Used for identifying previous selected row after fort complete to set as selected row.
72       *  If not set, column 0 is used.
73       *  @param keyColumnIndex model index
74       */
75      public void setKeyColumnIndex (int keyColumnIndex)
76      {
77          p_keyColumnIndex = keyColumnIndex;
78      }   //  setKeyColumnIndex
79  
80      /**
81       *  Get Model index of Key Column
82       *  @return model index
83       */
84      public int getKeyColumnIndex()
85      {
86          return p_keyColumnIndex;
87      }   //  getKeyColumnIndex
88  
89      /**
90       *  Get Current Row Key Column Value
91       *  @return value or null
92       */
93      public Object   getSelectedKeyColumnValue()
94      {
95          int row = getSelectedRow();
96          if (row != -1 && p_keyColumnIndex != -1)
97              return getModel().getValueAt(row, p_keyColumnIndex);
98          return null;
99      }   //  getKeyColumnValue
100 
101     /**
102      *  Get Selected Value or null
103      *  @return value
104      */
105     public Object   getSelectedValue()
106     {
107         int row = getSelectedRow();
108         int col = getSelectedColumn();
109         if (row == -1 || col == -1)
110             return null;
111         return getValueAt(row, col);
112     }   //  getSelectedValue
113 
114     /**
115      *  Stop Table Editors and remove focus
116      *  @param saveValue save value
117      */
118     public void stopEditor (boolean saveValue)
119     {
120         //  MultiRow - remove editors
121         ChangeEvent   ce = new ChangeEvent  (this);
122         if (saveValue)
123             editingStopped(ce);
124         else
125             editingCanceled(ce);
126         //
127         if (getInputContext() != null)
128             getInputContext().endComposition();
129         //  change focus to next
130         transferFocus();
131     }   //  stopEditor
132 
133     /*************************************************************************/
134 
135     /**
136      *  Size Columns.
137      *  Assumes you use Column Identifier to indicate displayed columns
138      */
139     public void autoSize()
140     {
141         TableModel   model = this.getModel();
142         int size = model.getColumnCount();
143         //  for all columns
144         for (int c = 0; c < size; c++)
145         {
146             TableColumn   column = getColumnModel().getColumn(c);
147             //  Not displayed columns
148             if (column.getIdentifier() == null
149                 || column.getMaxWidth() == 0
150                 || column.getIdentifier().toString().length() == 0)
151                 continue;
152 
153             int width = 0;
154             //  Header
155             TableCellRenderer   renderer = column.getHeaderRenderer();
156             Component   comp = null;
157             if (renderer == null)
158                 renderer = new DefaultTableCellRenderer  ();
159             else
160                 comp = renderer.getTableCellRendererComponent
161                     (this, column.getHeaderValue(), false, false, 0, 0);
162             //
163             if (comp != null)
164             {
165                 width = comp.getPreferredSize().width + SLACK;
166                 width = Math.max(width, comp.getWidth());
167 
168                 //  Cells
169                 int col = column.getModelIndex();
170                 int maxRow = Math.min(30, getRowCount());
171                 try
172                 {
173                     for (int row = 0; row < maxRow; row++)
174                     {
175                         renderer = getCellRenderer(row, col);
176                         comp = renderer.getTableCellRendererComponent
177                             (this, getValueAt(row, col), false, false, row, col);
178                         int rowWidth = comp.getPreferredSize().width + SLACK;
179                         width = Math.max(width, rowWidth);
180                     }
181                 }
182                 catch (Exception   e)
183                 {
184                     System.out.println(column.getIdentifier());
185                     e.printStackTrace();
186                 }
187                 //  Width not greater than 250
188                 width = Math.min(MAXSIZE, width);
189             }
190             //
191             column.setPreferredWidth(width);
192         }   //  for all columns
193     }   //  autoSize
194 
195     /**
196      *  Sort Table
197      *  @param modelColumnIndex model column sort index
198      */
199     protected void sort (int modelColumnIndex)
200     {
201         int rows = getRowCount();
202         if (rows == 0)
203             return;
204         //  other column
205         if (modelColumnIndex != p_lastSortIndex)
206             p_asc = true;
207         else
208             p_asc = !p_asc;
209         p_lastSortIndex = modelColumnIndex;
210         //
211     //  System.out.println("CTable.sort #" + modelColumnIndex + " - rows=" + rows + ", asc=" + p_asc);
212 
213         //  Selection
214         Object   selected = null;
215         int selRow = getSelectedRow();
216         int selCol = p_keyColumnIndex == -1 ? 0 : p_keyColumnIndex; //  used to identify current row
217         if (getSelectedRow() >= 0)
218             selected = getValueAt(selRow, selCol);
219 
220         //  Prepare sorting
221         DefaultTableModel   model = (DefaultTableModel  )getModel();
222         MSort sort = new MSort(0, null);
223         sort.setSortAsc(p_asc);
224         //  while something to sort
225         sorting:
226         while (true)
227         {
228             //  Create sortList
229             ArrayList   sortList = new ArrayList  (rows);
230             //  fill with data entity
231             for (int i = 0; i < rows; i++)
232             {
233                 Object   value = model.getValueAt(i, modelColumnIndex);
234                 sortList.add(new MSort(i, value));
235             }
236             //  sort list it
237             Collections.sort(sortList, sort);
238             //  move out of sequence row
239             for (int i = 0; i < rows; i++)
240             {
241                 int index = ((MSort)sortList.get(i)).index;
242                 if (i != index)
243                 {
244         //          Log.trace(Log.l4_Data, "move " + i + " to " + index);
245                     model.moveRow(i,i, index);
246                     continue sorting;
247                 }
248             }
249             //  we are done
250         //  Log.trace(Log.l4_Data, "done");
251             break;
252         }   //  while something to sort
253 
254         //  selection
255         clearSelection();
256         if (selected != null)
257         {
258             for (int r = 0; r < rows; r++)
259             {
260                 if (selected.equals(getValueAt(r, selCol)))
261                 {
262                     setRowSelectionInterval(r,r);
263                     break;
264                 }
265             }
266         }   //  selected != null
267     }   //  sort
268 
269     /**
270      *  String Representation
271      *  @return info
272      */
273     public String   toString()
274     {
275         return new StringBuffer  ("CTable[").append(getModel()).append("]").toString();
276     }   //  toString
277 
278     /*************************************************************************/
279 
280     /**
281      *  MouseListener
282      */
283     class CTableMouseListener extends MouseAdapter  
284     {
285         /**
286          *  Constructor
287          */
288         public CTableMouseListener()
289         {
290             super();
291         }   //  CTableMouseListener
292 
293         /**
294          *  Mouse clicked
295          *  @param e event
296          */
297         public void mouseClicked (MouseEvent   e)
298         {
299             int vc = getColumnModel().getColumnIndexAtX(e.getX());
300         //  Log.trace(Log.l1_User, "Sort " + vc + "=" + getColumnModel().getColumn(vc).getHeaderValue());
301             int mc = convertColumnIndexToModel(vc);
302             sort(mc);
303         }
304     }   //  CTableMouseListener
305 
306 }   //  CTable
307
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags