KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > columba > mail > gui > table > model > HeaderTableModel


1 // The contents of this file are subject to the Mozilla Public License Version
2 // 1.1
3 //(the "License"); you may not use this file except in compliance with the
4 //License. You may obtain a copy of the License at http://www.mozilla.org/MPL/
5 //
6 //Software distributed under the License is distributed on an "AS IS" basis,
7 //WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
8 //for the specific language governing rights and
9 //limitations under the License.
10 //
11 //The Original Code is "The Columba Project"
12 //
13 //The Initial Developers of the Original Code are Frederik Dietz and Timo
14 // Stich.
15 //Portions created by Frederik Dietz and Timo Stich are Copyright (C) 2003.
16 //
17 //All Rights Reserved.
18 package org.columba.mail.gui.table.model;
19
20 import java.util.Enumeration JavaDoc;
21 import java.util.HashMap JavaDoc;
22 import java.util.List JavaDoc;
23 import java.util.Map JavaDoc;
24 import java.util.Vector JavaDoc;
25
26 import javax.swing.event.ChangeEvent JavaDoc;
27 import javax.swing.event.ListSelectionEvent JavaDoc;
28 import javax.swing.event.TableColumnModelEvent JavaDoc;
29 import javax.swing.tree.DefaultTreeModel JavaDoc;
30 import javax.swing.tree.TreePath JavaDoc;
31
32 import org.columba.mail.gui.table.IHeaderTableModel;
33 import org.columba.mail.message.ColumbaHeader;
34 import org.columba.mail.message.ICloseableIterator;
35 import org.columba.mail.message.IColumbaHeader;
36 import org.columba.mail.message.IHeaderList;
37 import org.frapuccino.treetable.AbstractTreeTableModel;
38 import org.frapuccino.treetable.CustomTreeTableCellRenderer;
39
40 public class HeaderTableModel extends AbstractTreeTableModel implements IHeaderTableModel {
41
42     /**
43      * list of column IDs
44      */
45     private List JavaDoc columns = new Vector JavaDoc();
46
47     protected IHeaderList headerList;
48
49     /**
50      *
51      * We cache all <class>MessageNode </class> here.
52      *
53      * This is much faster than searching through the complete <class>HeaderList
54      * </class> all the time.
55      *
56      */
57     protected Map JavaDoc map = new HashMap JavaDoc();
58
59     protected MessageNode root;
60
61     private boolean enableThreadedView;
62     
63     private Vector JavaDoc visitors = new Vector JavaDoc();
64
65     public HeaderTableModel() {
66     }
67
68     public HeaderTableModel(String JavaDoc[] c) {
69         // add array to vector
70 for (int i = 0; i < c.length; i++) {
71             columns.add(c[i]);
72         }
73     }
74     
75     public void registerVisitor(ModelVisitor visitor) {
76         visitors.add(visitor);
77     }
78
79     /**
80      * ***************************** implements TableModelModifier
81      * ******************
82      */
83
84     /*
85      * (non-Javadoc)
86      *
87      * @see org.columba.mail.gui.table.model.TableModelModifier#modify(java.lang.Object[])
88      */
89     public void modify(Object JavaDoc[] uids) {
90         for (int i = 0; i < uids.length; i++) {
91             MessageNode node = (MessageNode) map.get(uids[i]);
92
93             IColumbaHeader header = getHeaderList().get(uids[i]);
94             if( header == null) continue;
95             
96             node.setUserObject(header);
97             
98             if (node != null) {
99                 // update treemodel
100 getTreeModel().nodeChanged(node);
101             }
102         }
103
104     }
105
106     /*
107      * (non-Javadoc)
108      *
109      * @see org.columba.mail.gui.table.model.TableModelModifier#remove(java.lang.Object[])
110      */
111     public void remove(Object JavaDoc[] uids) {
112         if (uids != null) {
113             for (int i = 0; i < uids.length; i++) {
114                 MessageNode node = (MessageNode) map.get(uids[i]);
115
116                 if (node != null) {
117                     map.remove(node);
118
119                     if (node.getParent() != null) {
120                         getTreeModel().removeNodeFromParent(node);
121                     }
122                 }
123             }
124
125         }
126     }
127
128     public void reset() {
129         if (root == null) {
130             root = new MessageNode(new ColumbaHeader(), "0");
131
132             tree.setRootNode(root);
133         }
134
135         // remove all children from tree
136 root.removeAllChildren();
137
138         // clear messagenode cache
139 map.clear();
140         
141         if ((headerList == null) || (headerList.count() == 0)) {
142             // table is empty
143 // -> just display empty table
144
145             getTreeModel().nodeStructureChanged(getRootNode());
146             
147             fireTableDataChanged();
148             
149             return;
150         }
151         
152         
153     }
154     
155     public void update() {
156         if ((headerList == null) || (headerList.count() == 0)) {
157             // table is empty
158 // -> just display empty table
159 root.removeAllChildren();
160             
161             getTreeModel().nodeStructureChanged(getRootNode());
162             
163             fireTableDataChanged();
164             
165             return;
166         }
167         
168         // add every header from HeaderList to the table as MessageNode
169 ICloseableIterator it;
170         for (it = headerList.keyIterator(); it.hasNext();) {
171             // get unique id
172 Object JavaDoc uid = it.next();
173             
174             if( !map.containsKey(uid)) {
175                 // get header
176 IColumbaHeader header = headerList.get(uid);
177
178                 // create MessageNode
179 MessageNode child = new MessageNode(header, uid);
180
181                 // add this node to cache
182 map.put(uid, child);
183
184                 // add node to tree
185 root.add(child);
186             }
187         }
188         it.close();
189
190         
191         Enumeration JavaDoc e = visitors.elements();
192         while (e.hasMoreElements()) {
193             ModelVisitor v = (ModelVisitor) e.nextElement();
194             v.visit(this);
195         }
196         
197         getTreeModel().nodeStructureChanged(getRootNode());
198         
199         fireTableDataChanged();
200     }
201     
202     public void clear() {
203         root = new MessageNode(new ColumbaHeader(), "0");
204         tree.setRootNode(root);
205
206     }
207
208     /*
209      * (non-Javadoc)
210      *
211      * @see org.columba.mail.gui.table.model.TableModelModifier#set(org.columba.mail.message.HeaderList)
212      */
213     public void set(IHeaderList headerList) {
214         this.headerList = headerList;
215
216         reset();
217         update();
218     }
219
220     /** ********************** getter/setter methods *************************** */
221     public void enableThreadedView(boolean b) {
222         enableThreadedView = b;
223     }
224
225     public MessageNode getRootNode() {
226         return root;
227     }
228
229     public IHeaderList getHeaderList() {
230         return headerList;
231     }
232
233     public MessageNode getMessageNode(Object JavaDoc uid) {
234         return (MessageNode) map.get(uid);
235     }
236
237     public DefaultTreeModel JavaDoc getTreeModel() {
238         return (DefaultTreeModel JavaDoc) getTree().getModel();
239     }
240
241     /** ******************* AbstractTableModel implementation ******************* */
242     public int getColumnCount() {
243         return columns.size();
244     }
245
246     public int getRowCount() {
247         if (getTree() != null) {
248             return getTree().getRowCount();
249         } else {
250             return 0;
251         }
252     }
253
254     public Object JavaDoc getValueAt(int row, int col) {
255         //if ( col == 0 ) return tree;
256 TreePath JavaDoc treePath = getTree().getPathForRow(row);
257         if( treePath == null) return null;
258         
259         return (MessageNode) treePath.getLastPathComponent();
260     }
261
262     /**
263      * Get row for node.
264      *
265      * @param node
266      * selected message node
267      * @return current row of node
268      */
269     public int getRow(MessageNode node) {
270
271         for (int i = 0; i < getTree().getRowCount(); i++) {
272             MessageNode n = (MessageNode) getValueAt(i, 0);
273             if (n.getUid().equals(node.getUid()))
274                 return i;
275         }
276
277         return -1;
278     }
279
280     public String JavaDoc getColumnName(int column) {
281         return (String JavaDoc) columns.get(column);
282     }
283
284     public int getColumnNumber(String JavaDoc name) {
285         for (int i = 0; i < getColumnCount(); i++) {
286             if (name.equals(getColumnName(i))) {
287                 return i;
288             }
289         }
290
291         return -1;
292     }
293
294     /**
295      * Get the class which is responsible for renderering this column.
296      * <p>
297      * If the threaded-view is enabled, return a custom tree cell renderer.
298      * <p>
299      *
300      * @see org.columba.mail.gui.table.TableView#enableThreadedView
301      */
302     public Class JavaDoc getColumnClass(int column) {
303         if (enableThreadedView) {
304             if (getColumnName(column).equals("Subject")) {
305                 return CustomTreeTableCellRenderer.class;
306             }
307         }
308
309         return getValueAt(0, column).getClass();
310     }
311
312     public boolean isCellEditable(int row, int col) {
313         String JavaDoc name = getColumnName(col);
314
315         if (name.equalsIgnoreCase("Subject")) {
316             return true;
317         }
318
319         return false;
320     }
321
322     /**
323      * Set column IDs
324      *
325      * @param c
326      * array of column IDs
327      */
328     public void setColumns(String JavaDoc[] c) {
329         columns = new Vector JavaDoc();
330
331         // add array to vector
332 for (int i = 0; i < c.length; i++) {
333             columns.add(c[i]);
334         }
335     }
336
337     /**
338      * Add column to table model.
339      *
340      * @param c
341      * new column ID
342      */
343     public void addColumn(String JavaDoc c) {
344         columns.add(c);
345     }
346
347     /**
348      * Clear column list.
349      *
350      */
351     public void clearColumns() {
352         columns.clear();
353     }
354
355     /**
356      * @see org.columba.mail.gui.table.IHeaderTableModel#getMessageNodeAtRow(int)
357      */
358     public MessageNode getMessageNodeAtRow(int index) {
359         return (MessageNode) getValueAt(index,0);
360     }
361
362     public void columnMarginChanged(ChangeEvent JavaDoc e) {
363     }
364
365     public void columnSelectionChanged(ListSelectionEvent JavaDoc e) {
366     }
367
368     public void columnAdded(TableColumnModelEvent JavaDoc e) {
369     }
370
371     public void columnMoved(TableColumnModelEvent JavaDoc e) {
372         if( e.getFromIndex() != e.getToIndex()) {
373             columns.add(e.getToIndex(),columns.remove(e.getFromIndex()));
374         }
375     }
376
377     public void columnRemoved(TableColumnModelEvent JavaDoc e) {
378     }
379
380 }
Popular Tags